apps/silcd/idlist.h

   1 /*
   2
   3   idlist.h
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 1997 - 2001 Pekka Riikonen
   8
   9   This program is free software; you can redistribute it and/or modify
  10   it under the terms of the GNU General Public License as published by
  11   the Free Software Foundation; either version 2 of the License, or
  12   (at your option) any later version.
  13
  14   This program is distributed in the hope that it will be useful,
  15   but WITHOUT ANY WARRANTY; without even the implied warranty of
  16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17   GNU General Public License for more details.
  18
  19 */
  20
  21 #ifndef IDLIST_H
  22 #define IDLIST_H
  23
  24 /* Forward declarations */
  25 typedef struct SilcServerEntryStruct *SilcServerEntry;
  26 typedef struct SilcClientEntryStruct *SilcClientEntry;
  27 typedef struct SilcChannelEntryStruct *SilcChannelEntry;
  28
  29 /* Context for holding cache information to periodically purge
  30    the cache. */
  31 typedef struct {
  32   SilcIDCache cache;
  33   void *timeout_queue;
  34 } *SilcIDListPurge;
  35
  36 /* Channel key re-key context. */
  37 typedef struct {
  38   void *context;
  39   SilcChannelEntry channel;
  40   uint32 key_len;
  41 } *SilcServerChannelRekey;
  42
  43 /* Generic rekey context for connections */
  44 typedef struct {
  45   /* Current sending encryption key, provided for re-key. The `pfs'
  46      is TRUE if the Perfect Forward Secrecy is performed in re-key. */
  47   unsigned char *send_enc_key;
  48   uint32 enc_key_len;
  49   int ske_group;
  50   bool pfs;
  51   uint32 timeout;
  52   void *context;
  53 } *SilcServerRekey;
  54
  55 /*
  56    Generic ID list data structure.
  57
  58    This structure is included in all ID list entries and it includes data
  59    pointers that are common to all ID entries.  This structure is always
  60    defined to the first field in the ID entries and is used to explicitly
  61    cast to this type without first explicitly casting to correct ID entry
  62    type.  Hence, the ID list entry is casted to this type to get this data
  63    from the ID entry (which is usually opaque pointer).
  64
  65    Note that some of the fields may be NULL.
  66
  67 */
  68 typedef struct {
  69   /* Send and receive symmetric keys */
  70   SilcCipher send_key;
  71   SilcCipher receive_key;
  72
  73   /* Re-key context */
  74   SilcServerRekey rekey;
  75
  76   /* Hash selected in the SKE protocol, NULL if not needed at all */
  77   SilcHash hash;
  78
  79   /* HMAC */
  80   SilcHmac hmac_send;
  81   SilcHmac hmac_receive;
  82
  83   /* Public key */
  84   SilcPublicKey public_key;
  85
  86   long last_receive;         /* Time last received data */
  87   long last_sent;            /* Time last sent data */
  88   bool registered;           /* Boolean whether connection is registered */
  89 } *SilcIDListData, SilcIDListDataStruct;
  90
  91 /*
  92    SILC Server entry object.
  93
  94    This entry holds information about servers in SILC network. However,
  95    contents of this entry is highly dependent of what kind of server we are
  96    (normal server or router server) and whether the entry is used as a local
  97    list or a global list. These factors dictates the contents of this entry.
  98
  99    This entry is defined as follows:
 100
 101    Server type   List type      Contents
 102    =======================================================================
 103    server        local list     Server itself
 104    server        global list    NULL
 105    router        local list     All servers is the cell
 106    router        global list    All servers in the SILC network
 107
 108    Following short description of the fields:
 109
 110    SilcIDListDataStruct data
 111
 112        Generic data structure to hold data common to all ID entries.
 113
 114    char *server_name
 115
 116        Logical name of the server. There is no limit of the length of the
 117        server name. This is usually the same name as defined in DNS.
 118
 119    uint8 server_type
 120
 121        Type of the server. SILC_SERVER or SILC_ROUTER are the possible
 122        choices for this.
 123
 124    SilcServerID *id
 125
 126        ID of the server. This includes all the relevant information about
 127        the server SILC will ever need. These are also the informations
 128        that is broadcasted between servers and routers in the SILC network.
 129
 130    char *server_info
 131    char *motd
 132
 133        Server info (from INFO command) saved temporarily and motd (from
 134        MOTD command) saved temporarily.
 135
 136    SilcServerEntry router
 137
 138        This is a pointer back to the server list. This is the router server
 139        where this server is connected to. If this is the router itself and
 140        it doesn't have a route this is NULL.
 141
 142    SilcCipher send_key
 143    SilcCipher receive_key
 144
 145        Data sending and receiving keys.
 146
 147    void *connection
 148
 149        A pointer, usually, to the socket list for fast referencing to
 150        the data used in connection with this server.  This may be anything
 151        but as just said, this is usually pointer to the socket connection
 152        list.
 153
 154 */
 155 struct SilcServerEntryStruct {
 156   /* Generic data structure. DO NOT add anything before this! */
 157   SilcIDListDataStruct data;
 158
 159   char *server_name;
 160   uint8 server_type;
 161   SilcServerID *id;
 162   char *server_info;
 163   char *motd;
 164
 165   /* Pointer to the router */
 166   SilcServerEntry router;
 167
 168   /* Connection data */
 169   void *connection;
 170 };
 171
 172 /*
 173    SILC Channel Client entry structure.
 174
 175    This entry used only by the SilcChannelEntry object and it holds
 176    information about current clients (ie. users) on channel. Following
 177    short description of the fields:
 178
 179    SilcClientEntry client
 180
 181        Pointer to the client list. This is the client currently on channel.
 182
 183    uint32 mode
 184
 185        Client's current mode on the channel.
 186
 187    SilcChannelEntry channel
 188
 189        Back pointer back to channel. As this structure is also used by
 190        SilcClientEntry we have this here for fast access to the channel when
 191        used by SilcClientEntry.
 192
 193 */
 194 typedef struct SilcChannelClientEntryStruct {
 195   SilcClientEntry client;
 196   uint32 mode;
 197   SilcChannelEntry channel;
 198 } *SilcChannelClientEntry;
 199
 200 /*
 201    SILC Client entry object.
 202
 203    This entry holds information about connected clients ie. users in the SILC
 204    network. The contents of this entrt is depended on whether we are normal
 205    server or router server and whether the list is a local or global list.
 206
 207    This entry is defined as follows:
 208
 209    Server type   List type      Contents
 210    =======================================================================
 211    server        local list     All clients in server
 212    server        global list    NULL
 213    router        local list     All clients in cell
 214    router        global list    All clients in SILC
 215
 216    Following short description of the fields:
 217
 218    SilcIDListDataStruct data
 219
 220        Generic data structure to hold data common to all ID entries.
 221
 222    unsigned char *nickname
 223
 224        The nickname of the client.
 225
 226    char *servername
 227
 228        The name of the server where the client is from. MAy be NULL.
 229
 230    char username
 231
 232        Client's usename. This is defined in the following manner:
 233
 234        Server type   List type      Contents
 235        ====================================================
 236        server        local list     User's name
 237        router        local list     NULL
 238        router        global list    NULL
 239
 240        Router doesn't hold this information since it is not vital data
 241        for the router. If this information is needed by the client it is
 242        fetched when it is needed.
 243
 244    char userinfo
 245
 246        Information about user. This is free information and can be virtually
 247        anything. This is defined in following manner:
 248
 249        Server type   List type      Contents
 250        ====================================================
 251        server        local list     User's information
 252        router        local list     NULL
 253        router        global list    NULL
 254
 255        Router doesn't hold this information since it is not vital data
 256        for the router. If this information is needed by the client it is
 257        fetched when it is needed.
 258
 259    SilcClientID *id
 260
 261        ID of the client. This includes all the information SILC will ever
 262        need. Notice that no nickname of the user is saved anywhere. This is
 263        beacuse of SilcClientID includes 88 bit hash value of the user's
 264        nickname which can be used to track down specific user by their
 265        nickname. Nickname is not relevant information that would need to be
 266        saved as plain.
 267
 268    uint32 mode
 269
 270        Client's mode.  Client maybe for example server operator or
 271        router operator (SILC operator).
 272
 273    long last_command
 274
 275        Time of last time client executed command. We are strict and will
 276        not allow any command to be exeucted more than once in about
 277        2 seconds. This is result of normal time().
 278
 279    uint8 fast_command
 280
 281        Counter to check command bursts.  By default, up to 5 commands
 282        are allowed before limiting the execution.  See command flags
 283        for more detail.
 284
 285    SilcServerEntry router
 286
 287        This is a pointer to the server list. This is the router server whose
 288        cell this client is coming from. This is used to route messages to
 289        this client.
 290
 291    SilcHashTable channels;
 292
 293        All the channels this client has joined.  The context saved in the
 294        hash table shares memory with the channel entrys `user_list' hash
 295        table.
 296
 297    void *connection
 298
 299        A pointer, usually, to the socket list for fast referencing to
 300        the data used in connection with this client.  This may be anything
 301        but as just said, this is usually pointer to the socket connection
 302        list.
 303
 304 */
 305 struct SilcClientEntryStruct {
 306   /* Generic data structure. DO NOT add anything before this! */
 307   SilcIDListDataStruct data;
 308
 309   unsigned char *nickname;
 310   char *servername;
 311   char *username;
 312   char *userinfo;
 313   SilcClientID *id;
 314   uint32 mode;
 315
 316   long last_command;
 317   uint8 fast_command;
 318
 319   /* Pointer to the router */
 320   SilcServerEntry router;
 321
 322   /* All channels this client has joined */
 323   SilcHashTable channels;
 324
 325   /* Connection data */
 326   void *connection;
 327 };
 328
 329 /*
 330    SILC Channel entry object.
 331
 332    This entry holds information about channels in SILC network. The contents
 333    of this entry is depended on whether we are normal server or router server
 334    and whether the list is a local or global list.
 335
 336    This entry is defined as follows:
 337
 338    Server type   List type      Contents
 339    =======================================================================
 340    server        local list     All channels in server
 341    server        global list    NULL
 342    router        local list     All channels in cell
 343    router        global list    All channels in SILC
 344
 345    Following short description of the fields:
 346
 347    char *channel_name
 348
 349        Logical name of the channel.
 350
 351    uint32 mode
 352
 353        Current mode of the channel.  See lib/silccore/silcchannel.h for
 354        all modes.
 355
 356    SilcChannelID *id
 357
 358        ID of the channel. This includes all the information SILC will ever
 359        need.
 360
 361    bool global_users
 362
 363        Boolean value to tell whether there are users outside this server
 364        on this channel. This is set to TRUE if router sends message to
 365        the server that there are users outside your server on your
 366        channel as well. This way server knows that messages needs to be
 367        sent to the router for further routing. If this is a normal
 368        server and this channel is not created on this server this field
 369        is always TRUE. If this server is a router this field is ignored.
 370
 371    char *topic
 372
 373        Current topic of the channel.
 374
 375    char *cipher
 376
 377        Default cipher of the channel. If this is NULL then server picks
 378        the cipher to be used. This can be set at SILC_COMMAND_JOIN.
 379
 380    char *hmac_name
 381
 382        Default hmac of the channel. If this is NULL then server picks
 383        the cipher to be used. This can be set at SILC_COMMAND_JOIN.
 384
 385    SilcPublicKey founder_key
 386    SilcAuthMethod founder_method
 387    unsigned char *founder_passwd
 388    uint32 founder_passwd_len
 389
 390        If the SILC_CMODE_FOUNDER_AUTH has been set then these will include
 391        the founder's public key, authentication method and the password
 392        if the method is SILC_AUTH_PASSWORD.  If it is SILC_AUTH_PUBLIC_KEY
 393        then the `founder_passwd' is NULL.
 394
 395    SilcHashTable user_list
 396
 397        All users joined on this channel.  Note that the context saved to
 398        this entry shares memory with the client entrys `channels' hash
 399        table.
 400
 401    SilcServerEntry router
 402
 403        This is a pointer to the server list. This is the router server
 404        whose cell this channel belongs to. This is used to route messages
 405        to this channel.
 406
 407    SilcCipher channel_key
 408
 409        The key of the channel (the cipher actually).
 410
 411    unsigned char *key
 412    uint32 key_len
 413
 414        Raw key data of the channel key.
 415
 416    unsigned char iv[SILC_CIPHER_MAX_IV_SIZE]
 417
 418        Current initial vector. Initial vector is received always along
 419        with the channel packet. By default this is filled with NULL.
 420
 421    SilcHmac hmac;
 422
 423        HMAC of the channel.
 424
 425    SilcServerChannelRekey rekey
 426
 427        Channel key re-key context.
 428
 429 */
 430 struct SilcChannelEntryStruct {
 431   char *channel_name;
 432   uint32 mode;
 433   SilcChannelID *id;
 434   bool global_users;
 435   char *topic;
 436   char *cipher;
 437   char *hmac_name;
 438
 439   SilcPublicKey founder_key;
 440   SilcAuthMethod founder_method;
 441   unsigned char *founder_passwd;
 442   uint32 founder_passwd_len;
 443
 444   uint32 user_limit;
 445   unsigned char *passphrase;
 446   char *invite_list;
 447   char *ban_list;
 448
 449   /* All users on this channel */
 450   SilcHashTable user_list;
 451
 452   /* Pointer to the router */
 453   SilcServerEntry router;
 454
 455   /* Channel keys */
 456   SilcCipher channel_key;
 457   unsigned char *key;
 458   uint32 key_len;
 459   unsigned char iv[SILC_CIPHER_MAX_IV_SIZE];
 460   SilcHmac hmac;
 461
 462   SilcServerChannelRekey rekey;
 463 };
 464
 465 /*
 466    SILC ID List object.
 467
 468    As for remainder these lists are defined as follows:
 469
 470    Entry list (cache)  Server type   List type      Contents
 471    =======================================================================
 472    servers             server        local list     Server itself
 473    servers             server        global list    NULL
 474    servers             router        local list     All servers in cell
 475    servers             router        global list    All servers in SILC
 476
 477    clients             server        local list     All clients in server
 478    clients             server        global list    NULL
 479    clients             router        local list     All clients in cell
 480    clients             router        global list    All clients in SILC
 481
 482    channels            server        local list     All channels in server
 483    channels            server        global list    NULL
 484    channels            router        local list     All channels in cell
 485    channels            router        global list    All channels in SILC
 486
 487    As seen on the list normal server never defines a global list. This is
 488    because of normal server don't know anything about anything global data,
 489    they get it from the router if and when they need it. Routers, on the
 490    other hand, always define local and global lists because routers really
 491    know all the relevant data in the SILC network.
 492
 493    This object is used as local and global list by the server/router.
 494    Above table shows how this is defined on different conditions.
 495
 496    This object holds pointers to the ID cache system. Every ID cache entry
 497    has a specific context pointer to allocated entry (server, client or
 498    channel entry).
 499
 500 */
 501 typedef struct SilcIDListStruct {
 502   SilcIDCache servers;
 503   SilcIDCache clients;
 504   SilcIDCache channels;
 505 } *SilcIDList;
 506
 507 /*
 508    ID Entry for Unknown connections.
 509
 510    This is used during authentication phases where we still don't know
 511    what kind of connection remote connection is, hence, we will use this
 512    structure instead until we know what type of connection remote end is.
 513
 514    This is not in any list. This is always individually allocated and
 515    used as such.
 516
 517 */
 518 typedef struct {
 519   /* Generic data structure. DO NOT add anything before this! */
 520   SilcIDListDataStruct data;
 521 } *SilcUnknownEntry;
 522
 523 /* Prototypes */
 524 void silc_idlist_add_data(void *entry, SilcIDListData idata);
 525 void silc_idlist_del_data(void *entry);
 526 SILC_TASK_CALLBACK_GLOBAL(silc_idlist_purge);
 527 SilcServerEntry
 528 silc_idlist_add_server(SilcIDList id_list,
 529                        char *server_name, int server_type,
 530                        SilcServerID *id, SilcServerEntry router,
 531                        void *connection);
 532 SilcServerEntry
 533 silc_idlist_find_server_by_id(SilcIDList id_list, SilcServerID *id,
 534                               SilcIDCacheEntry *ret_entry);
 535 SilcServerEntry
 536 silc_idlist_find_server_by_name(SilcIDList id_list, char *name,
 537                                 SilcIDCacheEntry *ret_entry);
 538 SilcServerEntry
 539 silc_idlist_find_server_by_conn(SilcIDList id_list, char *hostname,
 540                                 int port, SilcIDCacheEntry *ret_entry);
 541 SilcServerEntry
 542 silc_idlist_replace_server_id(SilcIDList id_list, SilcServerID *old_id,
 543                               SilcServerID *new_id);
 544 int silc_idlist_del_server(SilcIDList id_list, SilcServerEntry entry);
 545 SilcClientEntry
 546 silc_idlist_add_client(SilcIDList id_list, char *nickname, char *username,
 547                        char *userinfo, SilcClientID *id,
 548                        SilcServerEntry router, void *connection);
 549 int silc_idlist_del_client(SilcIDList id_list, SilcClientEntry entry);
 550 int silc_idlist_get_clients_by_nickname(SilcIDList id_list, char *nickname,
 551                                         char *server,
 552                                         SilcClientEntry **clients,
 553                                         uint32 *clients_count);
 554 int silc_idlist_get_clients_by_hash(SilcIDList id_list, char *nickname,
 555                                     SilcHash md5hash,
 556                                     SilcClientEntry **clients,
 557                                     uint32 *clients_count);
 558 SilcClientEntry
 559 silc_idlist_find_client_by_id(SilcIDList id_list, SilcClientID *id,
 560                               SilcIDCacheEntry *ret_entry);
 561 SilcClientEntry
 562 silc_idlist_replace_client_id(SilcIDList id_list, SilcClientID *old_id,
 563                               SilcClientID *new_id);
 564 void silc_idlist_client_destructor(SilcIDCache cache,
 565                                    SilcIDCacheEntry entry);
 566 SilcChannelEntry
 567 silc_idlist_add_channel(SilcIDList id_list, char *channel_name, int mode,
 568                         SilcChannelID *id, SilcServerEntry router,
 569                         SilcCipher channel_key, SilcHmac hmac);
 570 int silc_idlist_del_channel(SilcIDList id_list, SilcChannelEntry entry);
 571 SilcChannelEntry
 572 silc_idlist_find_channel_by_name(SilcIDList id_list, char *name,
 573                                  SilcIDCacheEntry *ret_entry);
 574 SilcChannelEntry
 575 silc_idlist_find_channel_by_id(SilcIDList id_list, SilcChannelID *id,
 576                                SilcIDCacheEntry *ret_entry);
 577 SilcChannelEntry
 578 silc_idlist_replace_channel_id(SilcIDList id_list, SilcChannelID *old_id,
 579                                SilcChannelID *new_id);
 580 SilcChannelEntry *
 581 silc_idlist_get_channels(SilcIDList id_list, SilcChannelID *channel_id,
 582                          uint32 *channels_count);
 583
 584 #endif