lib/silcclient/client.h

   1 /*
   2
   3   client.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 CLIENT_H
  22 #define CLIENT_H
  23
  24 /* Forward declarations */
  25 typedef struct SilcClientStruct *SilcClient;
  26 typedef struct SilcClientConnectionStruct *SilcClientConnection;
  27 typedef struct SilcClientPingStruct SilcClientPing;
  28 typedef struct SilcClientAwayStruct SilcClientAway;
  29 typedef struct SilcClientKeyAgreementStruct *SilcClientKeyAgreement;
  30
  31 #include "idlist.h"
  32 #include "command.h"
  33 #include "silcapi.h"
  34
  35 /* Connection structure used in client to associate all the important
  36    connection specific data to this structure. */
  37 struct SilcClientConnectionStruct {
  38   /*
  39    * Local data
  40    */
  41   char *nickname;
  42
  43   /* Local client ID for this connection */
  44   SilcClientID *local_id;
  45
  46   /* Decoded local ID so that the above defined ID would not have
  47      to be decoded for every packet. */
  48   unsigned char *local_id_data;
  49   unsigned int local_id_data_len;
  50
  51   /* Own client entry. */
  52   SilcClientEntry local_entry;
  53
  54   /*
  55    * Remote data
  56    */
  57   char *remote_host;
  58   int remote_port;
  59   int remote_type;
  60   char *remote_info;
  61
  62   /* Remote server ID for this connection */
  63   SilcServerID *remote_id;
  64
  65   /* Decoded remote ID so that the above defined ID would not have
  66      to be decoded for every packet. */
  67   unsigned char *remote_id_data;
  68   unsigned int remote_id_data_len;
  69
  70   /*
  71    * Common data
  72    */
  73   /* Keys */
  74   SilcCipher send_key;
  75   SilcCipher receive_key;
  76   SilcHmac hmac;
  77   unsigned char *hmac_key;
  78   unsigned int hmac_key_len;
  79
  80   /* Client ID and Channel ID cache. Messages transmitted in SILC network
  81      are done using different unique ID's. These are the cache for
  82      thoses ID's used in the communication. */
  83   SilcIDCache client_cache;
  84   SilcIDCache channel_cache;
  85   SilcIDCache server_cache;
  86
  87   /* Current channel on window. All channels are saved (allocated) into
  88      the cache entries. */
  89   SilcChannelEntry current_channel;
  90
  91   /* Socket connection object for this connection (window). This
  92      object will have a back-pointer to this window object for fast
  93      referencing (sock->user_data). */
  94   SilcSocketConnection sock;
  95
  96   /* Pending command queue for this connection */
  97   SilcDList pending_commands;
  98
  99   /* Current command identifier, 0 not used */
 100   unsigned short cmd_ident;
 101
 102   /* Requested pings. */
 103   SilcClientPing *ping;
 104   unsigned int ping_count;
 105
 106   /* Set away message */
 107   SilcClientAway *away;
 108
 109   /* Pointer back to the SilcClient. This object is passed to the application
 110      and the actual client object is accesible through this pointer. */
 111   SilcClient client;
 112
 113   /* User data context. Library does not touch this. */
 114   void *context;
 115 };
 116
 117 /* Main client structure. */
 118 struct SilcClientStruct {
 119   /*
 120    * Public data. All the following pointers must be set by the allocator
 121    * of this structure.
 122    */
 123
 124   /* Users's username, hostname and realname. */
 125   char *username;
 126   char *hostname;
 127   char *realname;
 128
 129   /* Private and public key of the user. */
 130   SilcPKCS pkcs;
 131   SilcPublicKey public_key;
 132   SilcPrivateKey private_key;
 133
 134   /* Application specific user data pointer. Client library does not
 135      touch this. */
 136   void *application;
 137
 138   /*
 139    * Private data. Following pointers are used internally by the client
 140    * library and should be considered read-only fields.
 141    */
 142
 143   /* All client operations that are implemented in the application. */
 144   SilcClientOperations *ops;
 145
 146   /* SILC client task queues */
 147   SilcTaskQueue io_queue;
 148   SilcTaskQueue timeout_queue;
 149   SilcTaskQueue generic_queue;
 150
 151   /* Table of connections in client. All the connection data is saved here. */
 152   SilcClientConnection *conns;
 153   unsigned int conns_count;
 154
 155   /* Generic cipher and hash objects. These can be used and referenced
 156      by the application as well. */
 157   SilcCipher none_cipher;
 158   SilcHash md5hash;
 159   SilcHash sha1hash;
 160   SilcHmac md5hmac;
 161   SilcHmac sha1hmac;
 162
 163   /* Random Number Generator. Application should use this as its primary
 164      random number generator. */
 165   SilcRng rng;
 166 };
 167
 168 /* Macros */
 169
 170 /* Registers generic task for file descriptor for reading from network and
 171    writing to network. As being generic task the actual task is allocated
 172    only once and after that the same task applies to all registered fd's. */
 173 #define SILC_CLIENT_REGISTER_CONNECTION_FOR_IO(fd)                      \
 174 do {                                                                    \
 175   SilcTask tmptask = silc_task_register(client->generic_queue, (fd),    \
 176                                         silc_client_packet_process,     \
 177                                         context, 0, 0,                  \
 178                                         SILC_TASK_GENERIC,              \
 179                                         SILC_TASK_PRI_NORMAL);          \
 180   silc_task_set_iotype(tmptask, SILC_TASK_WRITE);                       \
 181 } while(0)
 182
 183 #define SILC_CLIENT_SET_CONNECTION_FOR_INPUT(fd)                \
 184 do {                                                            \
 185   silc_schedule_set_listen_fd((fd), (1L << SILC_TASK_READ));    \
 186 } while(0)                                                      \
 187
 188 #define SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(fd)               \
 189 do {                                                            \
 190   silc_schedule_set_listen_fd((fd), ((1L << SILC_TASK_READ) |   \
 191                                      (1L << SILC_TASK_WRITE))); \
 192 } while(0)
 193
 194 /* Finds socket connection object by file descriptor */
 195 #define SILC_CLIENT_GET_SOCK(__x, __fd, __sock)         \
 196 do {                                                    \
 197   int __i;                                              \
 198                                                         \
 199   for (__i = 0; __i < (__x)->conns_count; __i++)        \
 200     if ((__x)->conns[__i]->sock->sock == (__fd))        \
 201       break;                                            \
 202                                                         \
 203   if (__i >= (__x)->conns_count)                        \
 204     (__sock) = NULL;                                    \
 205  (__sock) = (__x)->conns[__i]->sock;                    \
 206 } while(0)
 207
 208 /* Prototypes (some of the prototypes are defined in the silcapi.h) */
 209
 210 void silc_client_packet_send(SilcClient client,
 211                              SilcSocketConnection sock,
 212                              SilcPacketType type,
 213                              void *dst_id,
 214                              SilcIdType dst_id_type,
 215                              SilcCipher cipher,
 216                              SilcHmac hmac,
 217                              unsigned char *data,
 218                              unsigned int data_len,
 219                              int force_send);
 220 void silc_client_disconnected_by_server(SilcClient client,
 221                                         SilcSocketConnection sock,
 222                                         SilcBuffer message);
 223 void silc_client_error_by_server(SilcClient client,
 224                                  SilcSocketConnection sock,
 225                                  SilcBuffer message);
 226 void silc_client_receive_new_id(SilcClient client,
 227                                 SilcSocketConnection sock,
 228                                 SilcIDPayload idp);
 229 SilcChannelEntry silc_client_new_channel_id(SilcClient client,
 230                                             SilcSocketConnection sock,
 231                                             char *channel_name,
 232                                             unsigned int mode,
 233                                             SilcIDPayload idp);
 234 void silc_client_save_channel_key(SilcClientConnection conn,
 235                                   SilcBuffer key_payload,
 236                                   SilcChannelEntry channel);
 237 void silc_client_receive_channel_key(SilcClient client,
 238                                      SilcSocketConnection sock,
 239                                      SilcBuffer packet);
 240 void silc_client_channel_message(SilcClient client,
 241                                  SilcSocketConnection sock,
 242                                  SilcPacketContext *packet);
 243 void silc_client_remove_from_channels(SilcClient client,
 244                                       SilcClientConnection conn,
 245                                       SilcClientEntry client_entry);
 246 void silc_client_replace_from_channels(SilcClient client,
 247                                        SilcClientConnection conn,
 248                                        SilcClientEntry old,
 249                                        SilcClientEntry new);
 250 char *silc_client_chmode(unsigned int mode);
 251 char *silc_client_chumode(unsigned int mode);
 252 char *silc_client_chumode_char(unsigned int mode);
 253 void silc_client_process_failure(SilcClient client,
 254                                  SilcSocketConnection sock,
 255                                  SilcPacketContext *packet);
 256 void silc_client_key_agreement(SilcClient client,
 257                                SilcSocketConnection sock,
 258                                SilcPacketContext *packet);
 259 void silc_client_notify_by_server(SilcClient client,
 260                                   SilcSocketConnection sock,
 261                                   SilcPacketContext *packet);
 262 void silc_client_private_message(SilcClient client,
 263                                  SilcSocketConnection sock,
 264                                  SilcPacketContext *packet);
 265 #endif