Navigation



Ignore:
Timestamp:
Mar 24, 2014, 9:13:38 PM (10 years ago)
Author:
Thomas Klausner <tk@giga.or.at>
Branch:
default
Phase:
public
Message:

Remove whitespace at end of line.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • extensions/rt_redirect/redir_entries.c

    r740 r1259  
    4343{
    4444        int i;
    45        
     45
    4646        TRACE_ENTRY("");
    47        
     47
    4848        /* redirects_usages */
    4949        memset(&redirects_usages, 0, sizeof(redirects_usages));
    50        
     50
    5151        for (i = 0; i <= H_U_MAX; i++) {
    5252                CHECK_POSIX( pthread_rwlock_init( &redirects_usages[i].lock, NULL) );
    5353                fd_list_init( &redirects_usages[i].sentinel, &redirects_usages[i] );
    5454        }
    55        
     55
    5656        /* initialize the scores */
    5757        redirects_usages[ DONT_CACHE            ].score = FD_SCORE_REDIR_ONCE;
     
    7373        os0_t s;
    7474        size_t l;
    75        
     75
    7676        TRACE_ENTRY("%p %p %d %p %p %zd %p %zd", e, targets, rhu, qry, nh, nhlen, oh, ohlen)
    7777        ASSERT(e && targets && (rhu <= H_U_MAX) && qry && nh && nhlen && oh && ohlen);
    78        
     78
    7979        CHECK_MALLOC( entry = malloc(sizeof(struct redir_entry)) );
    8080        memset(entry, 0, sizeof(struct redir_entry));
    81        
     81
    8282        entry->eyec = REDIR_ENTRY_EYEC;
    83        
     83
    8484        CHECK_MALLOC( entry->from.s = os0dup(nh, nhlen) );
    8585        entry->from.l = nhlen;
    86        
     86
    8787        fd_list_init(&entry->target_peers_list, entry);
    8888        fd_list_move_end(&entry->target_peers_list, targets);
    89        
     89
    9090        fd_list_init(&entry->exp_list, entry);
    91        
     91
    9292        entry->type = rhu;
    9393        fd_list_init(&entry->redir_list, entry);
     
    9797                        entry->data.message.msg = qry;
    9898                        break;
    99                        
     99
    100100                case ALL_SESSION:
    101101                        {
     
    114114                        }
    115115                        break;
    116                
     116
    117117                case ALL_REALM:
    118118                        {
     
    132132                        }
    133133                        break;
    134                                
     134
    135135                case REALM_AND_APPLICATION:
    136136                        {
     
    156156                        }
    157157                        break;
    158                                
     158
    159159                case ALL_APPLICATION:
    160160                        {
     
    164164                        }
    165165                        break;
    166                        
     166
    167167                case ALL_HOST:
    168168                        CHECK_MALLOC( entry->data.host.s = os0dup(oh, ohlen) );
    169169                        entry->data.host.l = ohlen;
    170170                        break;
    171                        
     171
    172172                case ALL_USER:
    173173                        {
     
    187187                        }
    188188                        break;
    189                
     189
    190190                default:
    191191                        ASSERT(0);
    192192                        return EINVAL;
    193193        }
    194        
     194
    195195        /* We're done */
    196196        *e = entry;
     
    203203        unsigned long v1 = (unsigned long) d1->message.msg;
    204204        unsigned long v2 = (unsigned long) d2->message.msg;
    205         if (v1 > v2) 
     205        if (v1 > v2)
    206206                return 1;
    207207        if (v1 < v2)
     
    211211/* Compare two applications (REALM_AND_APPLICATION and ALL_APPLICATION) */
    212212static int compare_entries_appl(union matchdata * d1, union matchdata * d2) {
    213         if (d1->app.a > d2->app.a) 
     213        if (d1->app.a > d2->app.a)
    214214                return 1;
    215         if (d1->app.a < d2->app.a) 
     215        if (d1->app.a < d2->app.a)
    216216                return -1;
    217217        return 0;
     
    238238{
    239239        struct fd_list * li;
    240        
     240
    241241        TRACE_ENTRY("%p", e);
    242242        CHECK_PARAMS(e && (e->eyec == REDIR_ENTRY_EYEC));
    243        
     243
    244244        /* Write-Lock the line */
    245245        CHECK_POSIX( pthread_rwlock_wrlock( RWLOCK_REDIR(e) ) );
    246        
     246
    247247        for (li = redirects_usages[e->type].sentinel.next; li != &redirects_usages[e->type].sentinel; li = li->next) {
    248248                struct redir_entry * n = li->o;
     
    251251                        break;
    252252        }
    253        
     253
    254254        fd_list_insert_before(li, &e->redir_list);
    255        
     255
    256256        /* unLock the line */
    257257        CHECK_POSIX( pthread_rwlock_unlock( RWLOCK_REDIR(e) ) );
     
    265265        TRACE_ENTRY("%p", e);
    266266        CHECK_PARAMS(e && (e->eyec == REDIR_ENTRY_EYEC));
    267        
     267
    268268        /* If the entry is linked, lock the rwlock also */
    269269        if (!FD_IS_LIST_EMPTY(&e->redir_list)) {
     
    272272                CHECK_POSIX( pthread_rwlock_unlock( RWLOCK_REDIR(e) ) );
    273273        }
    274        
     274
    275275        /* Now unlink from other list */
    276276        fd_list_unlink(&e->exp_list);
    277        
     277
    278278        /* Empty the targets list */
    279279        while (!FD_IS_LIST_EMPTY(&e->target_peers_list)) {
    280280                struct redir_host * h = (struct redir_host *)e->target_peers_list.next->o;
    281                
     281
    282282                fd_list_unlink(&h->chain);
    283283                free(h->id);
    284284                free(h);
    285285        }
    286        
     286
    287287        /* Now we can destroy the data safely */
    288288        switch (e->type) {
     
    312312                        return EINVAL;
    313313        }
    314        
     314
    315315        free(e->from.s);
    316        
     316
    317317        free(e);
    318318        return 0;
Note: See TracChangeset for help on using the changeset viewer.