Changeset 4394

Show
Ignore:
Timestamp:
10/01/06 13:14:34 (2 years ago)
Author:
morris
Message:

Update for libwired

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trackerd/trunk/trackerd/commands.c

    r3991 r4394  
    283283static void wt_cmd_register(wi_array_t *arguments) { 
    284284        wt_client_t                                     *client = wt_client(); 
    285         wi_list_t                                      *list; 
    286         wi_list_node_t                         *node; 
     285        wi_enumerator_t                                *enumerator; 
     286        wi_array_t                                     *array; 
    287287        wi_address_t                            *address, *hostaddress; 
    288288        wi_url_t                                        *url; 
    …… 
    332332                        /* look up and compare with source address */ 
    333333                        passed = false; 
    334                         list = wi_host_addresses(wi_host_with_string(hostname)); 
     334                        array = wi_host_addresses(wi_host_with_string(hostname)); 
    335335                         
    336                         if(list) { 
    337                                 WI_LIST_FOREACH(list, node, hostaddress) { 
     336                        if(array) { 
     337                                enumerator = wi_array_data_enumerator(array); 
     338                                 
     339                                while((hostaddress = wi_enumerator_next_data(enumerator))) { 
    338340                                        if(wi_is_equal(hostaddress, address)) { 
    339341                                                passed = true; 

  • trackerd/trunk/trackerd/servers.c

    r4024 r4394  
    8282static wi_timer_t                                               *wt_servers_timer; 
    8383 
    84 wi_list_t                                                               *wt_servers; 
    85  
     84wi_array_t                                                              *wt_servers; 
    8685 
    8786static wi_runtime_id_t                                  wt_server_runtime_id = WI_RUNTIME_ID_NULL; 
    …… 
    9998        wt_server_runtime_id = wi_runtime_register_class(&wt_server_runtime_class); 
    10099 
    101         wt_servers = wi_list_init(wi_list_alloc()); 
     100        wt_servers = wi_array_init(wi_array_alloc()); 
    102101         
    103102        wt_servers_lock = wi_lock_init(wi_lock_alloc()); 
    …… 
    160159        interval = wi_time_interval(); 
    161160 
    162         wi_list_wrlock(wt_servers); 
     161        wi_array_wrlock(wt_servers); 
    163162        while((fread(&server_packed, sizeof(wt_server_packed_t), 1, fp)) > 0) { 
    164163                update = server_packed.update_time > 0 ? server_packed.update_time : server_packed.register_time; 
    …… 
    174173                        wi_lock_unlock(wt_status_lock); 
    175174 
    176                         wi_list_append_data(wt_servers, server); 
     175                        wi_array_add_data(wt_servers, server); 
    177176                        wi_release(server); 
    178177 
    …… 
    180179                } 
    181180        } 
    182         wi_list_unlock(wt_servers); 
     181        wi_array_unlock(wt_servers); 
    183182 
    184183        if(count > 0) { 
    …… 
    205204        static uint32_t                 version = WT_SERVER_VERSION; 
    206205        FILE                                    *fp; 
    207         wi_list_node_t                 *node; 
     206        wi_enumerator_t                        *enumerator; 
    208207        wt_server_t                             *server; 
    209208        wt_server_packed_t              server_packed; 
    …… 
    222221        fwrite(&version, 4, 1, fp); 
    223222 
    224         wi_list_rdlock(wt_servers); 
    225         WI_LIST_FOREACH(wt_servers, node, server) { 
     223        wi_array_rdlock(wt_servers); 
     224         
     225        enumerator = wi_array_data_enumerator(wt_servers); 
     226         
     227        while((server = wi_enumerator_next_data(enumerator))) { 
    226228                server_packed = wt_server_packed(server); 
    227229                fwrite(&server_packed, sizeof(wt_server_packed_t), 1, fp); 
    228230        } 
    229         wi_list_unlock(wt_servers); 
     231 
     232        wi_array_unlock(wt_servers); 
    230233 
    231234        fclose(fp); 
    …… 
    238241 
    239242static void wt_update_servers(wi_timer_t *timer) { 
    240         wi_list_node_t          *node, *next_node; 
    241243        wt_server_t                     *server; 
    242244        wi_time_interval_t      interval, update; 
    243         unsigned int            count = 0; 
    244  
    245         if(wi_list_count(wt_servers) > 0) { 
    246                 interval = wi_time_interval(); 
    247  
    248                 wi_list_rdlock(wt_servers); 
    249                 for(node = wi_list_first_node(wt_servers); node; node = next_node) { 
    250                         next_node       = wi_list_node_next_node(node); 
    251                         server          = wi_list_node_data(node); 
    252                         update          = server->update_time > 0.0 ? server->update_time : server->register_time; 
    253  
    254                         if(interval - update > wt_settings.minupdatetime) { 
    255                                 wi_log_warn(WI_STR("Deleting \"%@\" with URL %@: Last update %.0f seconds ago considered too slow"), 
    256                                         server->name, server->url, interval - update); 
    257  
    258                                 wt_server_stats_remove(server); 
    259                                 wi_list_remove_node(wt_servers, node); 
    260  
    261                                 count++; 
    262                         } 
    263                 } 
    264                 wi_list_unlock(wt_servers); 
    265  
    266                 if(count > 0) { 
    267                         wi_lock_lock(wt_status_lock); 
    268                         wt_write_status(true); 
    269                         wi_lock_unlock(wt_status_lock); 
    270  
    271                         wt_write_servers(); 
    272                 } 
     245        wi_boolean_t            changed = false; 
     246        uint32_t                        i, count; 
     247 
     248        wi_array_rdlock(wt_servers); 
     249                 
     250        count = wi_array_count(wt_servers); 
     251        interval = wi_time_interval(); 
     252 
     253        for(i = 0; i < count; i++) { 
     254                server = WI_ARRAY(wt_servers, i); 
     255                update = server->update_time > 0.0 ? server->update_time : server->register_time; 
     256 
     257                if(interval - update > wt_settings.minupdatetime) { 
     258                        wi_log_warn(WI_STR("Deleting \"%@\" with URL %@: Last update %.0f seconds ago considered too slow"), 
     259                                server->name, server->url, interval - update); 
     260 
     261                        wt_server_stats_remove(server); 
     262                         
     263                        wi_array_remove_data_at_index(wt_servers, i); 
     264                         
     265                        count--; 
     266                        i--; 
     267                        changed = true; 
     268                } 
     269        } 
     270 
     271        wi_array_unlock(wt_servers); 
     272 
     273        if(changed) { 
     274                wi_lock_lock(wt_status_lock); 
     275                wt_write_status(true); 
     276                wi_lock_unlock(wt_status_lock); 
     277 
     278                wt_write_servers(); 
    273279        } 
    274280} 
    …… 
    285291 
    286292wt_server_t * wt_server_init(wt_server_t *server) { 
    287         wi_list_wrlock(wt_servers); 
    288         wi_list_append_data(wt_servers, server); 
    289         wi_list_unlock(wt_servers); 
     293        wi_array_wrlock(wt_servers); 
     294        wi_array_add_data(wt_servers, server); 
     295        wi_array_unlock(wt_servers); 
    290296         
    291297        wi_lock_lock(wt_status_lock); 
    …… 
    375381 
    376382wt_server_t * wt_server_with_ip(wi_string_t *ip) { 
    377         wi_list_node_t *node; 
     383        wi_enumerator_t        *enumerator; 
    378384        wt_server_t             *server, *value = NULL; 
    379385 
    380         wi_list_rdlock(wt_servers); 
    381         WI_LIST_FOREACH(wt_servers, node, server) { 
     386        wi_array_rdlock(wt_servers); 
     387         
     388        enumerator = wi_array_data_enumerator(wt_servers); 
     389         
     390        while((server = wi_enumerator_next_data(enumerator))) { 
    382391                if(wi_is_equal(server->ip, ip)) { 
    383392                        value = server; 
    …… 
    386395                } 
    387396        } 
    388         wi_list_unlock(wt_servers); 
     397 
     398        wi_array_unlock(wt_servers); 
    389399 
    390400        return value; 
    …… 
    394404 
    395405wt_server_t * wt_server_with_key(wi_string_t *key) { 
    396         wi_list_node_t *node; 
     406        wi_enumerator_t        *enumerator; 
    397407        wt_server_t             *server, *value = NULL; 
    398408 
    399         wi_list_rdlock(wt_servers); 
    400         WI_LIST_FOREACH(wt_servers, node, server) { 
     409        wi_array_rdlock(wt_servers); 
     410 
     411        enumerator = wi_array_data_enumerator(wt_servers); 
     412         
     413        while((server = wi_enumerator_next_data(enumerator))) { 
    401414                if(wi_is_equal(server->key, key)) { 
    402415                        value = server; 
    …… 
    405418                } 
    406419        } 
    407         wi_list_unlock(wt_servers); 
     420         
     421        wi_array_unlock(wt_servers); 
    408422 
    409423        return value; 

  • trackerd/trunk/trackerd/servers.h

    r4024 r4394  
    7676 
    7777 
    78 extern wi_list_t                                      *wt_servers; 
     78extern wi_array_t                                     *wt_servers; 
    7979 
    8080#endif /* WT_SERVERS_H */ 

  • trackerd/trunk/trackerd/settings.c

    r3947 r4394  
    4242 
    4343static wi_settings_spec_t               wt_wi_settings_spec[] = { 
    44         { "address",                    WI_SETTINGS_STRING_LIST,      &wt_settings.address }, 
     44        { "address",                    WI_SETTINGS_STRING_ARRAY,     &wt_settings.address }, 
    4545        { "allow multiple",             WI_SETTINGS_BOOL,                       &wt_settings.allowmultiple }, 
    4646        { "banlist",                    WI_SETTINGS_PATH,                       &wt_settings.banlist }, 

  • trackerd/trunk/trackerd/settings.h

    r3947 r4394  
    4040        wi_string_t                                             *name; 
    4141        wi_string_t                                             *description; 
    42         wi_list_t                                             *address; 
     42        wi_array_t                                            *address; 
    4343        unsigned int                                    port; 
    4444 

  • trackerd/trunk/trackerd/tracker.c

    r3947 r4394  
    4444 
    4545 
    46 static wi_list_t                                      *wt_tcp_sockets; 
    47 static wi_list_t                                      *wt_udp_sockets; 
     46static wi_array_t                                     *wt_tcp_sockets; 
     47static wi_array_t                                     *wt_udp_sockets; 
    4848 
    4949static wi_socket_context_t                      *wt_socket_context; 
    …… 
    5151 
    5252void wt_init_tracker(void) { 
    53         wi_list_t                              *list, *addresses; 
    54         wi_list_node_t                 *node, *next_node; 
     53        wi_enumerator_t                        *enumerator; 
     54        wi_array_t                             *array, *addresses; 
    5555        wi_address_t                    *address; 
    5656        wi_socket_t                             *tcp_socket, *udp_socket; 
    …… 
    5858        wi_address_family_t             family; 
    5959 
    60         wt_tcp_sockets  = wi_list_init(wi_list_alloc()); 
    61         wt_udp_sockets  = wi_list_init(wi_list_alloc()); 
    62         addresses               = wi_list_init(wi_list_alloc()); 
    63  
    64         if(wi_list_count(wt_settings.address) > 0) { 
     60        wt_tcp_sockets  = wi_array_init(wi_array_alloc()); 
     61        wt_udp_sockets  = wi_array_init(wi_array_alloc()); 
     62        addresses               = wi_array_init(wi_array_alloc()); 
     63 
     64        if(wi_array_count(wt_settings.address) > 0) { 
    6565                /* listen on configured addresses */ 
    66                 wi_list_rdlock(wt_settings.address); 
    67                 WI_LIST_FOREACH(wt_settings.address, node, string) { 
    68                         list = wi_host_addresses(wi_host_with_string(string)); 
    69  
    70                         if(list) 
    71                                 wi_list_append_data_from_list(addresses, list); 
     66                wi_array_rdlock(wt_settings.address); 
     67                 
     68                enumerator = wi_array_data_enumerator(wt_settings.address); 
     69                 
     70                while((string = wi_enumerator_next_data(enumerator))) { 
     71                        array = wi_host_addresses(wi_host_with_string(string)); 
     72 
     73                        if(array) 
     74                                wi_array_add_data_from_array(addresses, array); 
    7275                        else 
    7376                                wi_log_err(WI_STR("Could not resolve \"%@\": %m"), string); 
    7477                } 
    75                 wi_list_unlock(wt_settings.address); 
     78                 
     79                wi_array_unlock(wt_settings.address); 
    7680        } else { 
    7781                /* add wildcard addresses */ 
    78                 wi_list_append_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV4)); 
    79                 wi_list_append_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV6)); 
    80         } 
    81  
    82         for(node = wi_list_first_node(addresses); node; node = next_node) { 
    83                next_node       = wi_list_node_next_node(node); 
    84                address         = wi_list_node_data(node); 
     82                wi_array_add_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV4)); 
     83                wi_array_add_data(addresses, wi_address_wildcard_for_family(WI_ADDRESS_IPV6)); 
     84        } 
     85         
     86        enumerator = wi_array_data_enumerator(addresses); 
     87         
     88        while((address = wi_enumerator_next_data(enumerator))) { 
    8589                ip                      = wi_address_string(address); 
    8690                family          = wi_address_family(address); 
    87                 tcp_socket      = NULL; 
    88                 udp_socket      = NULL; 
    8991                 
    9092                /* force address family? */ 
    9193                if(wt_address_family != WI_ADDRESS_NULL && family != wt_address_family) 
    92                         goto next; 
     94                        continue; 
    9395                 
    9496                /* create sockets */ 
    9597                wi_address_set_port(address, wt_settings.port); 
    9698 
    97                 tcp_socket = wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP); 
    98                 udp_socket = wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_UDP); 
     99                tcp_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP)); 
     100                udp_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_UDP)); 
    99101                 
    100102                if(!tcp_socket || !udp_socket) { 
    101103                        wi_log_warn(WI_STR("Could not create socket for %@: %m"), ip); 
    102104                         
    103                         goto next; 
     105                        continue; 
    104106                } 
    105107                 
    …… 
    111113                                ip, wi_address_port(wi_socket_address(tcp_socket))); 
    112114 
    113                         goto next; 
     115                        continue; 
    114116                } 
    115117                 
    …… 
    118120                                ip, wi_address_port(wi_socket_address(udp_socket))); 
    119121 
    120                         goto next; 
     122                        continue; 
    121123                } 
    122124                 
    123125                /* add to list of sockets */ 
    124                 wi_list_append_data(wt_tcp_sockets, tcp_socket); 
    125                 wi_list_append_data(wt_udp_sockets, udp_socket); 
     126                wi_array_add_data(wt_tcp_sockets, tcp_socket); 
     127                wi_array_add_data(wt_udp_sockets, udp_socket); 
    126128                 
    127129                wi_log_info(WI_STR("Listening on %@ port %d"), 
    128130                        ip, wt_settings.port); 
    129  
    130 next: 
    131                 wi_release(tcp_socket); 
    132                 wi_release(udp_socket); 
    133         } 
    134  
    135         if(wi_list_count(wt_tcp_sockets) == 0 || wi_list_count(wt_udp_sockets) == 0) 
     131        } 
     132 
     133        if(wi_array_count(wt_tcp_sockets) == 0 || wi_array_count(wt_udp_sockets) == 0) 
    136134                wi_log_err(WI_STR("No addresses available for listening")); 
    137135