Changeset 4402

Show
Ignore:
Timestamp:
10/03/06 10:02:26 (2 years ago)
Author:
morris
Message:

Update for libwired

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • wired/trunk/wired/accounts.c

    r3899 r4402  
    595595 
    596596void wd_accounts_reload_users(void) { 
    597         wi_list_node_t         *node
     597        wi_enumerator_t                *enumerator
    598598        wd_client_t                     *client; 
    599  
    600         wi_list_rdlock(wd_clients); 
    601         WI_LIST_FOREACH(wd_clients, node, client) 
     599         
     600        wi_hash_rdlock(wd_clients); 
     601         
     602        enumerator = wi_hash_data_enumerator(wd_clients); 
     603 
     604        while((client = wi_enumerator_next_data(enumerator))) 
    602605                _wd_accounts_reload_client(client); 
    603         wi_list_unlock(wd_clients); 
     606 
     607        wi_hash_unlock(wd_clients); 
    604608} 
    605609 
     
    647651 
    648652static void _wd_accounts_reload_user(wi_string_t *name) { 
    649         wi_list_node_t         *node
     653        wi_enumerator_t                *enumerator
    650654        wd_client_t                     *client; 
    651655 
    652         wi_list_rdlock(wd_clients); 
    653         WI_LIST_FOREACH(wd_clients, node, client) { 
     656        wi_hash_rdlock(wd_clients); 
     657         
     658        enumerator = wi_hash_data_enumerator(wd_clients); 
     659         
     660        while((client = wi_enumerator_next_data(enumerator))) { 
    654661                if(wi_is_equal(client->account->name, name)) 
    655662                        _wd_accounts_reload_client(client); 
    656663        } 
    657         wi_list_unlock(wd_clients); 
     664 
     665        wi_hash_unlock(wd_clients); 
    658666} 
    659667 
     
    661669 
    662670static void _wd_accounts_reload_group(wi_string_t *name) { 
    663         wi_list_node_t         *node
     671        wi_enumerator_t                *enumerator
    664672        wd_client_t                     *client; 
    665673 
    666         wi_list_rdlock(wd_clients); 
    667         WI_LIST_FOREACH(wd_clients, node, client) { 
     674        wi_hash_rdlock(wd_clients); 
     675         
     676        enumerator = wi_hash_data_enumerator(wd_clients); 
     677         
     678        while((client = wi_enumerator_next_data(enumerator))) { 
    668679                if(wi_is_equal(client->account->group, name)) 
    669680                        _wd_accounts_reload_client(client); 
    670681        } 
    671         wi_list_unlock(wd_clients); 
     682 
     683        wi_hash_unlock(wd_clients); 
    672684} 
    673685 
     
    693705        wi_lock_unlock(client->flag_lock); 
    694706         
    695         if(client->admin != admin) { 
    696                 wd_broadcast_lock(); 
     707        if(client->admin != admin) 
    697708                wd_client_broadcast_status(client); 
    698                 wd_broadcast_unlock(); 
    699         } 
    700709 
    701710        wd_client_lock_socket(client); 
  • wired/trunk/wired/chats.c

    r4401 r4402  
    4141 
    4242 
     43wd_chat_t                                                       *wd_public_chat; 
     44 
    4345static wi_hash_t                                        *wd_chats; 
    4446 
     
    5557 
    5658void wd_init_chats(void) { 
    57         wd_chat_t               *chat; 
    58  
    5959        wd_chat_runtime_id = wi_runtime_register_class(&wd_chat_runtime_class); 
    6060 
    6161        wd_chats = wi_hash_init(wi_hash_alloc()); 
    6262 
    63         chat = wd_chat_init_public_chat(wd_chat_alloc()); 
    64         wd_chats_add_chat(chat); 
    65         wi_release(chat); 
     63        wd_public_chat = wd_chat_init_public_chat(wd_chat_alloc()); 
     64        wd_chats_add_chat(wd_public_chat); 
    6665} 
    6766 
     
    9796         
    9897        wi_hash_rdlock(wd_chats); 
    99         chat = wi_hash_data_for_key(wd_chats, wi_number_with_int32(chat->cid)); 
     98        chat = wi_autorelease(wi_retain(wi_hash_data_for_key(wd_chats, wi_number_with_int32(cid)))); 
    10099        wi_hash_unlock(wd_chats); 
    101100         
     
    117116                chat = wi_hash_data_for_key(wd_chats, key); 
    118117                 
     118                wi_array_wrlock(chat->clients); 
    119119                wi_array_remove_data(chat->clients, client); 
     120                wi_array_unlock(chat->clients); 
    120121 
    121122                if(chat->cid != WD_PUBLIC_CID && wi_array_count(chat->clients) == 0) 
     
    212213 
    213214        if(chat) { 
    214                 wi_hash_rdlock(wd_chats); 
     215                wi_array_rdlock(chat->clients); 
    215216                 
    216217                enumerator = wi_array_data_enumerator(chat->clients); 
     
    224225                } 
    225226                         
    226                 wi_hash_unlock(wd_chats); 
     227                wi_array_unlock(chat->clients); 
    227228        } 
    228229 
     
    233234 
    234235void wd_chat_add_client(wd_chat_t *chat, wd_client_t *client) { 
    235         wd_broadcast_lock(); 
    236         wd_broadcast(chat->cid, 302, WI_STR("%u%c%u%c%u%c%u%c%u%c%#@%c%#@%c%#@%c%#@%c%#@%c%#@"), 
     236        wd_broadcast(chat, 302, WI_STR("%u%c%u%c%u%c%u%c%u%c%#@%c%#@%c%#@%c%#@%c%#@%c%#@"), 
    237237                                 chat->cid,                     WD_FIELD_SEPARATOR, 
    238238                                 client->uid,           WD_FIELD_SEPARATOR, 
     
    246246                                 client->status,        WD_FIELD_SEPARATOR, 
    247247                                 client->image); 
    248         wd_broadcast_unlock(); 
    249          
    250         wi_hash_wrlock(wd_chats); 
     248         
     249        wi_array_wrlock(chat->clients); 
    251250        wi_array_add_data(chat->clients, client); 
    252         wi_hash_unlock(wd_chats); 
     251        wi_array_unlock(chat->clients); 
    253252 
    254253        if(chat->topic.topic) 
     
    259258 
    260259void wd_chat_remove_client(wd_chat_t *chat, wd_client_t *client) { 
    261         wi_hash_wrlock(wd_chats); 
     260        wi_array_wrlock(chat->clients); 
    262261        wi_array_remove_data(chat->clients, client); 
    263  
    264         if(chat->cid != WD_PUBLIC_CID && wi_array_count(chat->clients) == 0) 
     262        wi_array_unlock(chat->clients); 
     263 
     264        if(chat->cid != WD_PUBLIC_CID && wi_array_count(chat->clients) == 0) { 
     265                wi_hash_wrlock(wd_chats); 
    265266                wi_hash_remove_data_for_key(wd_chats, wi_number_with_int32(chat->cid)); 
    266  
    267         wi_hash_unlock(wd_chats); 
     267                wi_hash_unlock(wd_chats); 
     268        } 
    268269} 
    269270 
     
    274275        wd_client_t             *client; 
    275276         
    276         wi_array_rdlock(wd_chats); 
     277        wi_array_rdlock(chat->clients); 
    277278         
    278279        enumerator = wi_array_data_enumerator(chat->clients); 
     
    295296        } 
    296297         
    297         wi_array_unlock(wd_chats); 
     298        wi_array_unlock(chat->clients); 
    298299 
    299300        wd_reply(311, WI_STR("%u"), chat->cid); 
     
    346347        string = wi_date_iso8601_string(chat->topic.date); 
    347348         
    348         wd_broadcast(chat->cid, 341, WI_STR("%u%c%#@%c%#@%c%#@%c%#@%c%#@"), 
     349        wd_broadcast(chat, 341, WI_STR("%u%c%#@%c%#@%c%#@%c%#@%c%#@"), 
    349350                                 chat->cid,                             WD_FIELD_SEPARATOR, 
    350351                                 chat->topic.nick,              WD_FIELD_SEPARATOR, 
     
    354355                                 chat->topic.topic); 
    355356} 
     357 
     358 
     359 
     360void wd_chat_broadcast_leave(wd_chat_t *chat, wd_client_t *client) { 
     361        wd_broadcast(chat, 303, WI_STR("%u%c%u"), 
     362                                 chat->cid,             WD_FIELD_SEPARATOR, 
     363                                 client->uid); 
     364} 
  • wired/trunk/wired/chats.h

    r4401 r4402  
    8383void                                                                    wd_chat_reply_topic(wd_chat_t *); 
    8484void                                                                    wd_chat_broadcast_topic(wd_chat_t *); 
     85void                                                                    wd_chat_broadcast_leave(wd_chat_t *, wd_client_t *); 
    8586 
    8687 
     88extern wd_chat_t                                                *wd_public_chat; 
     89 
    8790#endif /* WD_CHATS_H */ 
  • wired/trunk/wired/clients.c

    r3850 r4402  
    5656static wi_timer_t                                               *wd_clients_timer; 
    5757 
    58 wi_list_t                                                             *wd_clients; 
     58wi_hash_t                                                             *wd_clients; 
    5959 
    6060static wi_runtime_id_t                                  wd_client_runtime_id = WI_RUNTIME_ID_NULL; 
     
    7272        wd_client_runtime_id = wi_runtime_register_class(&wd_client_runtime_class); 
    7373 
    74         wd_clients = wi_list_init(wi_list_alloc()); 
     74        wd_clients = wi_hash_init(wi_hash_alloc()); 
    7575 
    7676        wd_clients_timer = wi_timer_init_with_function(wi_timer_alloc(), 
     
    8989 
    9090static void wd_update_clients(wi_timer_t *timer) { 
    91         wi_list_node_t         *node
     91        wi_enumerator_t                *enumerator
    9292        wd_client_t                     *client; 
    9393        wi_time_interval_t      interval; 
    9494 
    95         if(wi_list_count(wd_clients) > 0) { 
     95        wi_hash_rdlock(wd_clients); 
     96 
     97        if(wi_hash_count(wd_clients) > 0) { 
    9698                interval = wi_time_interval(); 
    9799 
    98                 wd_broadcast_lock(); 
    99                 wi_list_rdlock(wd_clients); 
    100                 WI_LIST_FOREACH(wd_clients, node, client) { 
     100                enumerator = wi_hash_data_enumerator(wd_clients); 
     101                 
     102                while((client = wi_enumerator_next_data(enumerator))) { 
    101103                        if(client->idle || client->state != WD_CLIENT_STATE_LOGGED_IN) 
    102104                                continue; 
     
    108110                        } 
    109111                } 
    110                 wi_list_unlock(wd_clients); 
    111                 wd_broadcast_unlock(); 
    112112        } 
     113                 
     114        wi_hash_unlock(wd_clients); 
    113115} 
    114116 
     
    118120        wi_log_debug(WI_STR("Clients:")); 
    119121        wi_log_debug(WI_STR("%@"), wd_clients); 
     122} 
     123 
     124 
     125 
     126#pragma mark - 
     127 
     128void wd_clients_add_client(wd_client_t *client) { 
     129        wi_hash_wrlock(wd_clients); 
     130        wi_hash_set_data_for_key(wd_clients, client, wi_number_with_int32(client->uid)); 
     131        wi_hash_unlock(wd_clients); 
     132} 
     133 
     134 
     135 
     136void wd_clients_remove_client(wd_client_t *client) { 
     137        wd_chats_remove_client(client); 
     138        wd_transfers_remove_client(client); 
     139         
     140        wi_hash_wrlock(wd_clients); 
     141        wi_hash_remove_data_for_key(wd_clients, wi_number_with_int32(client->uid)); 
     142        wi_hash_unlock(wd_clients); 
     143} 
     144 
     145 
     146 
     147void wd_clients_remove_all_clients(void) { 
     148        wi_enumerator_t         *enumerator; 
     149        wd_client_t                     *client; 
     150 
     151        wi_hash_wrlock(wd_clients); 
     152         
     153        enumerator = wi_hash_data_enumerator(wd_clients); 
     154         
     155        while((client = wi_enumerator_next_data(enumerator))) { 
     156                wd_chats_remove_client(client); 
     157                wd_transfers_remove_client(client); 
     158        } 
     159 
     160        wi_hash_remove_all_data(wd_clients); 
     161         
     162        wi_hash_unlock(wd_clients); 
    120163} 
    121164 
     
    199242        static wd_uid_t         uid; 
    200243 
    201         if(wi_list_count(wd_clients) == 0) 
     244        if(wi_hash_count(wd_clients) == 0) 
    202245                uid = 0; 
    203246 
     
    238281 
    239282wd_client_t * wd_client_with_uid(wd_uid_t uid) { 
    240         wi_list_node_t  *node; 
    241         wd_client_t     *client, *value = NULL; 
    242  
    243         wi_list_rdlock(wd_clients); 
    244         WI_LIST_FOREACH(wd_clients, node, client) { 
    245                 if(client->uid == uid) { 
    246                         value = client; 
    247  
    248                         break; 
    249                 } 
    250         } 
    251         wi_list_unlock(wd_clients); 
    252  
    253         return value; 
     283        wd_client_t     *client; 
     284 
     285        wi_hash_rdlock(wd_clients); 
     286        client = wi_autorelease(wi_retain(wi_hash_data_for_key(wd_clients, wi_number_with_int32(uid)))); 
     287        wi_hash_unlock(wd_clients); 
     288         
     289        return client; 
    254290} 
    255291 
     
    259295 
    260296void wd_client_broadcast_status(wd_client_t *client) { 
    261         wd_broadcast(WD_PUBLIC_CID, 304, WI_STR("%u%c%u%c%u%c%u%c%#@%c%#@"), 
     297        wd_broadcast(wd_public_chat, 304, WI_STR("%u%c%u%c%u%c%u%c%#@%c%#@"), 
    262298                                 client->uid,           WD_FIELD_SEPARATOR, 
    263299                                 client->idle,          WD_FIELD_SEPARATOR, 
     
    267303                                 client->status); 
    268304} 
    269  
    270  
    271  
    272 void wd_client_broadcast_leave(wd_client_t *client, wd_cid_t cid) { 
    273         wd_broadcast(cid, 303, WI_STR("%u%c%u"), 
    274                                  cid,           WD_FIELD_SEPARATOR, 
    275                                  client->uid); 
    276 } 
    277  
    278  
    279  
    280 #pragma mark - 
    281  
    282 void wd_clients_add_client(wd_client_t *client) { 
    283         wi_list_wrlock(wd_clients); 
    284         wi_list_append_data(wd_clients, client); 
    285         wi_list_unlock(wd_clients); 
    286 } 
    287  
    288  
    289  
    290 void wd_clients_remove_client(wd_client_t *client) { 
    291         wd_chats_remove_client(client); 
    292         wd_transfers_remove_client(client); 
    293          
    294         wi_list_wrlock(wd_clients); 
    295         wi_list_remove_data(wd_clients, client); 
    296         wi_list_unlock(wd_clients); 
    297 } 
    298  
    299  
    300  
    301 void wd_clients_remove_all_clients(void) { 
    302         wi_list_node_t  *node; 
    303         wd_client_t     *client; 
    304  
    305         wi_list_wrlock(wd_clients); 
    306         WI_LIST_FOREACH(wd_clients, node, client) { 
    307                 wd_chats_remove_client(client); 
    308                 wd_transfers_remove_client(client); 
    309         } 
    310  
    311         wi_list_remove_all_data(wd_clients); 
    312         wi_list_unlock(wd_clients); 
    313 } 
  • wired/trunk/wired/clients.h

    r3847 r4402  
    9191void                                                                    wd_dump_clients(void); 
    9292 
     93void                                                                    wd_clients_add_client(wd_client_t *); 
     94void                                                                    wd_clients_remove_client(wd_client_t *); 
     95void                                                                    wd_clients_remove_all_clients(void); 
     96 
    9397wd_client_t *                                                   wd_client_alloc(void); 
    9498wd_client_t *                                                   wd_client_init_with_socket(wd_client_t *, wi_socket_t *); 
     
    103107 
    104108void                                                                    wd_client_broadcast_status(wd_client_t *); 
    105 void                                                                    wd_client_broadcast_leave(wd_client_t *, unsigned int); 
    106  
    107 void                                                                    wd_clients_add_client(wd_client_t *); 
    108 void                                                                    wd_clients_remove_client(wd_client_t *); 
    109 void                                                                    wd_clients_remove_all_clients(void); 
    110109 
    111110 
    112 extern wi_list_t                                              *wd_clients; 
     111extern wi_hash_t                                              *wd_clients; 
    113112 
    114113#endif /* WD_CLIENTS_H */ 
  • wired/trunk/wired/commands.c

    r4401 r4402  
    283283                client->state = WD_CLIENT_STATE_DISCONNECTED; 
    284284 
    285                 wd_broadcast_lock(); 
    286                 wd_client_broadcast_leave(client, WD_PUBLIC_CID); 
    287                 wd_broadcast_unlock(); 
     285                wd_chat_broadcast_leave(wd_public_chat, client); 
    288286        } 
    289287 
     
    340338                        client->idle = false; 
    341339 
    342                         wd_broadcast_lock(); 
    343340                        wd_client_broadcast_status(client); 
    344                         wd_broadcast_unlock(); 
    345341                } 
    346342        } 
     
    411407        } 
    412408 
    413         wd_broadcast_lock(); 
    414         wd_broadcast(WD_PUBLIC_CID, 307, WI_STR("%u%c%u%c%#@"), 
     409        wd_broadcast(wd_public_chat, 307, WI_STR("%u%c%u%c%#@"), 
    415410                                 peer->uid,             WD_FIELD_SEPARATOR, 
    416411                                 client->uid,   WD_FIELD_SEPARATOR, 
    417412                                 WI_ARRAY(arguments, 1)); 
    418         wd_broadcast_unlock(); 
    419413 
    420414        wi_log_ll(WI_STR("%@/%@/%@ banned %@/%@/%@"), 
     
    455449        } 
    456450 
    457         wd_broadcast_lock(); 
    458         wd_broadcast(WD_PUBLIC_CID, 309, WI_STR("%u%c%#@"), 
     451        wd_broadcast(wd_public_chat, 309, WI_STR("%u%c%#@"), 
    459452                                 client->uid,   WD_FIELD_SEPARATOR, 
    460453                                 WI_ARRAY(arguments, 0)); 
    461         wd_broadcast_unlock(); 
    462454} 
    463455 
     
    628620                return; 
    629621 
    630         wd_broadcast_lock(); 
    631         wd_broadcast(chat->cid, 332, WI_STR("%u%c%u"), 
     622        wd_broadcast(chat, 332, WI_STR("%u%c%u"), 
    632623                                 chat->cid,             WD_FIELD_SEPARATOR, 
    633624                                 client->uid); 
    634         wd_broadcast_unlock(); 
    635625} 
    636626 
     
    977967                client->icon = icon; 
    978968 
    979                 if(client->state == WD_CLIENT_STATE_LOGGED_IN) { 
    980                         wd_broadcast_lock(); 
     969                if(client->state == WD_CLIENT_STATE_LOGGED_IN) 
    981970                        wd_client_broadcast_status(client); 
    982                         wd_broadcast_unlock(); 
    983                 } 
    984971        } 
    985972 
     
    990977 
    991978                if(client->state == WD_CLIENT_STATE_LOGGED_IN) { 
    992                         wd_broadcast_lock(); 
    993                         wd_broadcast(WD_PUBLIC_CID, 340, WI_STR("%u%c%#@"), 
     979                        wd_broadcast(wd_public_chat, 340, WI_STR("%u%c%#@"), 
    994980                                                 client->uid,   WD_FIELD_SEPARATOR, 
    995981                                                 client->image); 
    996                         wd_broadcast_unlock(); 
    997982                } 
    998983        } 
     
    1007992static void wd_cmd_info(wi_array_t *arguments) { 
    1008993        wd_client_t                     *client = wd_client(); 
    1009         wi_list_node_t         *node
     994        wi_enumerator_t                *enumerator
    1010995        wi_string_t                     *info, *login, *idle, *downloads, *uploads; 
    1011996        wd_client_t                     *peer; 
     
    10311016        uploads         = wi_string(); 
    10321017 
    1033         wi_list_rdlock(wd_transfers); 
    1034         WI_LIST_FOREACH(wd_transfers, node, transfer) { 
     1018        wi_array_rdlock(wd_transfers); 
     1019         
     1020        enumerator = wi_array_data_enumerator(wd_transfers); 
     1021         
     1022        while((transfer = wi_enumerator_next_data(enumerator))) { 
    10351023                if(transfer->client == peer && transfer->state == WD_TRANSFER_RUNNING) { 
    10361024                        if(!client->account->view_dropboxes) { 
     
    10581046                } 
    10591047        } 
    1060         wi_list_unlock(wd_transfers); 
     1048         
     1049        wi_array_unlock(wd_transfers); 
    10611050         
    10621051        login   = wi_date_iso8601_string(wi_date_with_time_interval(peer->login_time)); 
     
    11791168        } 
    11801169 
    1181         wd_broadcast_lock(); 
    1182         wd_broadcast(WD_PUBLIC_CID, 306, WI_STR("%u%c%u%c%#@"), 
     1170        wd_broadcast(wd_public_chat, 306, WI_STR("%u%c%u%c%#@"), 
    11831171                                 peer->uid,             WD_FIELD_SEPARATOR, 
    11841172                                 client->uid,   WD_FIELD_SEPARATOR, 
    11851173                                 WI_ARRAY(arguments, 1)); 
    1186         wd_broadcast_unlock(); 
    11871174 
    11881175        wi_log_ll(WI_STR("%@/%@/%@ kicked %@/%@/%@"), 
     
    12171204 
    12181205        wd_chat_remove_client(chat, client); 
    1219  
    1220         wd_broadcast_lock(); 
    1221         wd_client_broadcast_leave(client, cid); 
    1222         wd_broadcast_unlock(); 
     1206        wd_chat_broadcast_leave(chat, client); 
    12231207} 
    12241208 
     
    12891273        count = wi_array_count(array); 
    12901274         
    1291         wd_broadcast_lock(); 
    12921275        for(i = 0; i < count; i++) { 
    12931276                string = WI_ARRAY(array, i); 
    12941277                 
    12951278                if(wi_string_length(string) > 0) { 
    1296                         wd_broadcast(cid, 301, WI_STR("%u%c%u%c%#@"), 
     1279                        wd_broadcast(chat, 301, WI_STR("%u%c%u%c%#@"), 
    12971280                                                 cid,                   WD_FIELD_SEPARATOR, 
    12981281                                                 client->uid,   WD_FIELD_SEPARATOR, 
     
    13001283                } 
    13011284        } 
    1302         wd_broadcast_unlock(); 
    13031285} 
    13041286 
     
    13971379                client->nick = wi_retain(nick); 
    13981380 
    1399                 if(client->state == WD_CLIENT_STATE_LOGGED_IN) { 
    1400                         wd_broadcast_lock(); 
     1381                if(client->state == WD_CLIENT_STATE_LOGGED_IN) 
    14011382                        wd_client_broadcast_status(client); 
    1402                         wd_broadcast_unlock(); 
    1403                 } 
    14041383        } 
    14051384} 
     
    16371616        count = wi_array_count(array); 
    16381617         
    1639         wd_broadcast_lock(); 
    16401618        for(i = 0; i < count; i++) { 
    16411619                string = WI_ARRAY(array, i); 
    16421620                 
    16431621                if(wi_string_length(string) > 0) { 
    1644                         wd_broadcast(cid, 300, WI_STR("%u%c%u%c%#@"), 
     1622                        wd_broadcast(chat, 300, WI_STR("%u%c%u%c%#@"), 
    16451623                                                 cid,                   WD_FIELD_SEPARATOR, 
    16461624                                                 client->uid,   WD_FIELD_SEPARATOR, 
     
    16481626                } 
    16491627        } 
    1650         wd_broadcast_unlock(); 
    16511628} 
    16521629 
     
    17091686                client->status = wi_retain(status); 
    17101687 
    1711                 if(client->state == WD_CLIENT_STATE_LOGGED_IN) { 
    1712                         wd_broadcast_lock(); 
     1688                if(client->state == WD_CLIENT_STATE_LOGGED_IN) 
    17131689                        wd_client_broadcast_status(client); 
    1714                         wd_broadcast_unlock(); 
    1715                 } 
    17161690        } 
    17171691} 
     
    17471721        wd_chat_set_topic(chat, WI_ARRAY(arguments, 1)); 
    17481722 
    1749         wd_broadcast_lock(); 
    17501723        wd_chat_broadcast_topic(chat); 
    1751         wd_broadcast_unlock(); 
    17521724} 
    17531725 
  • wired/trunk/wired/news.c

    r3779 r4402  
    133133        } 
    134134         
    135         wd_broadcast_lock(); 
    136         wd_broadcast(WD_PUBLIC_CID, 322, WI_STR("%#@"), post); 
    137         wd_broadcast_unlock(); 
     135        wd_broadcast(wd_public_chat, 322, WI_STR("%#@"), post); 
    138136 
    139137end: 
  • wired/trunk/wired/server.c

    r4401 r4402  
    108108                        continue; 
    109109                 
    110                 /* set ports */ 
     110                /* create sockets */ 
    111111                wi_address_set_port(address, wd_settings.port); 
     112                control_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP)); 
     113 
    112114                wi_address_set_port(address, wd_settings.port + 1); 
    113  
    114                 /* create sockets */ 
    115                 control_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP)); 
    116115                transfer_socket = wi_autorelease(wi_socket_init_with_address(wi_socket_alloc(), address, WI_SOCKET_TCP)); 
    117116         
     
    197196                string = wi_date_iso8601_string(wd_start_date); 
    198197                 
    199                 wd_broadcast_lock(); 
    200                 wd_broadcast(WD_PUBLIC_CID, 200, WI_STR("%#@%c%#@%c%#@%c%#@%c%#@%c%u%c%llu"), 
     198                wd_broadcast(wd_public_chat, 200, WI_STR("%#@%c%#@%c%#@%c%#@%c%#@%c%u%c%llu"), 
    201199                                         wd_server_version_string,              WD_FIELD_SEPARATOR, 
    202200                                         wd_protocol_version_string,    WD_FIELD_SEPARATOR, 
     
    206204                                         wd_files_unique_count,                 WD_FIELD_SEPARATOR, 
    207205                                         wd_files_unique_size); 
    208                 wd_broadcast_unlock(); 
    209206        } 
    210207 
     
    482479 
    483480 
    484 #pragma mark - 
    485  
    486 void wd_broadcast(wd_cid_t cid, unsigned int n, wi_string_t *fmt, ...) { 
     481void wd_broadcast(wd_chat_t *chat, unsigned int n, wi_string_t *fmt, ...) { 
    487482        wi_enumerator_t *enumerator; 
    488         wd_chat_t               *chat; 
    489483        wd_client_t             *client; 
    490484        wi_string_t             *string; 
     
    495489        va_end(ap); 
    496490         
    497         chat = wd_chats_chat_with_cid(cid); 
     491        wi_array_rdlock(chat->clients); 
    498492 
    499493        enumerator = wi_array_data_enumerator(chat->clients); 
     
    506500                } 
    507501        } 
     502         
     503        wi_array_unlock(chat->clients); 
    508504 
    509505        wi_release(string); 
    510506} 
    511  
    512  
    513  
    514 void wd_broadcast_lock(void) { 
    515         wi_list_rdlock(wd_chats); 
    516 } 
    517  
    518  
    519  
    520 void wd_broadcast_unlock(void) { 
    521         wi_list_unlock(wd_chats); 
    522 } 
  • wired/trunk/wired/server.h

    r3551 r4402  
    5454void                                                            wd_reply_error(void); 
    5555void                                                            wd_sreply(wi_socket_t *, unsigned int, wi_string_t *, ...); 
    56  
    57 void                                                            wd_broadcast(wd_cid_t, unsigned int, wi_string_t *, ...); 
    58 void                                                            wd_broadcast_lock(void); 
    59 void                                                            wd_broadcast_unlock(void); 
     56void                                                            wd_broadcast(wd_chat_t *, unsigned int, wi_string_t *, ...); 
    6057 
    6158 
  • wired/trunk/wired/trackers.c

    r4401 r4402  
    8080 
    8181 
    82 static wi_list_t                                              *wd_trackers; 
     82static wi_array_t                                             *wd_trackers; 
    8383 
    8484static wi_timer_t                                               *wd_trackers_register_timer; 
     
    101101        wd_tracker_runtime_id = wi_runtime_register_class(&wd_tracker_runtime_class); 
    102102 
    103         wd_trackers = wi_list_init(wi_list_alloc()); 
     103        wd_trackers = wi_array_init(wi_array_alloc()); 
    104104 
    105105        wd_trackers_register_timer = 
     
    126126        uint32_t                        port; 
    127127         
    128         wi_list_wrlock(wd_trackers); 
    129         wi_list_remove_all_data(wd_trackers); 
     128        wi_array_wrlock(wd_trackers); 
     129        wi_array_remove_all_data(wd_trackers); 
    130130         
    131131        enumerator = wi_array_data_enumerator(wd_settings.tracker); 
    132132         
    133133        while((string = wi_enumerator_next_data(enumerator))) { 
    134                 tracker = wd_tracker_init(wd_tracker_alloc()); 
    135                 url             = wi_url_init_with_string(wi_url_alloc(), string); 
     134                tracker = wi_autorelease(wd_tracker_init(wd_tracker_alloc())); 
     135                url             = wi_autorelease(wi_url_init_with_string(wi_url_alloc(), string)); 
    136136                 
    137137                if(!wi_url_is_valid(url)) { 
     
    139139                                string); 
    140140                         
    141                         goto next
     141                        continue
    142142                } 
    143143 
     
    147147                        wi_log_warn(WI_STR("Could not set SSL context: %m")); 
    148148                         
    149                         goto next
     149                        continue
    150150                } 
    151151 
     
    162162                        wi_log_warn(WI_STR("Could not resolve \"%@\": %m"), tracker->host); 
    163163                         
    164                         goto next
     164                        continue
    165165                } 
    166166                 
     
    175175                        wi_address_set_port(address, port); 
    176176                 
    177                 wi_list_append_data(wd_trackers, tracker); 
    178  
    179 next: 
    180                 wi_release(tracker); 
    181                 wi_release(url); 
    182         } 
    183          
    184         wi_list_unlock(wd_trackers); 
     177                wi_array_add_data(wd_trackers, tracker); 
     178        } 
     179         
     180        wi_array_unlock(wd_trackers); 
    185181} 
    186182 
     
    259255 
    260256void wd_trackers_register(wi_boolean_t update) { 
    261         if(wi_list_count(wd_trackers) > 0) { 
     257        if(wi_array_count(wd_trackers) > 0) { 
    262258                wi_release(wd_trackers_guest_account); 
    263259                 
     
    275271static void wd_trackers_register_thread(wi_runtime_instance_t *argument) { 
    276272        wi_pool_t                       *pool; 
     273        wi_enumerator_t         *enumerator; 
    277274        wi_number_t                     *number = argument; 
    278         wi_list_node_t          *node; 
    279275        wd_tracker_t            *tracker; 
    280276        wi_boolean_t            update; 
     
    283279        update = wi_number_bool(number); 
    284280         
    285         wi_list_rdlock(wd_trackers); 
    286         WI_LIST_FOREACH(wd_trackers, node, tracker) { 
     281        wi_array_rdlock(wd_trackers); 
     282         
     283        enumerator = wi_array_data_enumerator(wd_trackers); 
     284         
     285        while((tracker = wi_enumerator_next_data(enumerator))) { 
    287286                wd_tracker_register(tracker); 
    288287                 
     
    290289                        wd_tracker_update(tracker); 
    291290        } 
    292         wi_list_unlock(wd_trackers); 
     291         
     292        wi_array_unlock(wd_trackers); 
    293293         
    294294        if(update) 
     
    307307 
    308308static void wd_trackers_update(void) { 
    309         wi_list_node_t         *node
     309        wi_enumerator_t                *enumerator
    310310        wd_tracker_t            *tracker; 
    311311         
    312         wi_list_rdlock(wd_trackers); 
    313         WI_LIST_FOREACH(wd_trackers, node, tracker) { 
     312        wi_array_rdlock(wd_trackers); 
     313         
     314        enumerator = wi_array_data_enumerator(wd_trackers); 
     315         
     316        while((tracker = wi_enumerator_next_data(enumerator))) { 
    314317                if(tracker->active) 
    315318                        wd_tracker_update(tracker); 
    316319        } 
    317         wi_list_unlock(wd_trackers); 
     320 
     321        wi_array_unlock(wd_trackers); 
    318322} 
    319323 
    &hel