lib/silcclient/client_internal.h

   1 /*
   2
   3   client_internal.h
   4
   5   Author: Pekka Riikonen <priikone@silcnet.org>
   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; version 2 of the License.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18 */
  19
  20 #ifndef CLIENT_INTERNAL_H
  21 #define CLIENT_INTERNAL_H
  22
  23 /* Internal context for connection process. This is needed as we
  24    doing asynchronous connecting. */
  25 typedef struct {
  26   SilcClient client;
  27   SilcClientConnection conn;
  28   SilcTask task;
  29   int sock;
  30   char *host;
  31   int port;
  32   int tries;
  33   void *context;
  34 } SilcClientInternalConnectContext;
  35
  36 /* Structure to hold ping time information. Every PING command will
  37    add entry of this structure and is removed after reply to the ping
  38    as been received. */
  39 struct SilcClientPingStruct {
  40   time_t start_time;
  41   void *dest_id;
  42   char *dest_name;
  43 };
  44
  45 /* Structure to hold away messages set by user. This is mainly created
  46    for future extensions where away messages could be set according filters
  47    such as nickname and hostname. For now only one away message can
  48    be set in one connection. */
  49 struct SilcClientAwayStruct {
  50   char *away;
  51   struct SilcClientAwayStruct *next;
  52 };
  53
  54 /* Internal context for the client->internal pointer in the SilcClient. */
  55 struct SilcClientInternalStruct {
  56   /* All client operations that are implemented by the application. */
  57   SilcClientOperations *ops;
  58
  59   /* Client Parameters */
  60   SilcClientParams *params;
  61
  62   /* Table of connections in client. All the connection data is saved here. */
  63   SilcClientConnection *conns;
  64   SilcUInt32 conns_count;
  65
  66   /* Table of listenning sockets in client.  Client can have listeners
  67      (like key agreement protocol server) and those sockets are saved here.
  68      This table is checked always if the connection object cannot be found
  69      from the `conns' table. */
  70   SilcSocketConnection *sockets;
  71   SilcUInt32 sockets_count;
  72
  73   /* Registered commands */
  74   SilcList commands;
  75
  76   /* Generic cipher and hash objects. */
  77   SilcCipher none_cipher;
  78   SilcHash md5hash;
  79   SilcHash sha1hash;
  80   SilcHmac md5hmac;
  81   SilcHmac sha1hmac;
  82
  83   /* Client version. Used to compare to remote host's version strings. */
  84   char *silc_client_version;
  85 };
  86
  87 /* Macros */
  88
  89 /* Registers generic task for file descriptor for reading from network and
  90    writing to network. As being generic task the actual task is allocated
  91    only once and after that the same task applies to all registered fd's. */
  92 #define SILC_CLIENT_REGISTER_CONNECTION_FOR_IO(fd)      \
  93 do {                                                    \
  94   silc_schedule_task_add(client->schedule, (fd),        \
  95                          silc_client_packet_process,    \
  96                          context, 0, 0,                 \
  97                          SILC_TASK_GENERIC,             \
  98                          SILC_TASK_PRI_NORMAL);         \
  99 } while(0)
 100
 101 #define SILC_CLIENT_SET_CONNECTION_FOR_INPUT(s, fd)             \
 102 do {                                                            \
 103   silc_schedule_set_listen_fd((s), (fd), SILC_TASK_READ);       \
 104 } while(0)
 105
 106 #define SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(s, fd)            \
 107 do {                                                            \
 108   silc_schedule_set_listen_fd((s), (fd), (SILC_TASK_READ |      \
 109                                           SILC_TASK_WRITE));    \
 110 } while(0)
 111
 112 /* Finds socket connection object by file descriptor */
 113 #define SILC_CLIENT_GET_SOCK(__x, __fd, __sock)                 \
 114 do {                                                            \
 115   int __i;                                                      \
 116                                                                 \
 117   for (__i = 0; __i < (__x)->internal->conns_count; __i++)      \
 118     if ((__x)->internal->conns[__i] &&                          \
 119         (__x)->internal->conns[__i]->sock->sock == (__fd))      \
 120       break;                                                    \
 121                                                                 \
 122   if (__i >= (__x)->internal->conns_count) {                    \
 123     (__sock) = NULL;                                            \
 124     for (__i = 0; __i < (__x)->internal->sockets_count; __i++)  \
 125       if ((__x)->internal->sockets[__i] &&                      \
 126           (__x)->internal->sockets[__i]->sock == (__fd))        \
 127         (__sock) = (__x)->internal->sockets[__i];               \
 128   } else                                                        \
 129     (__sock) = (__x)->internal->conns[__i]->sock;               \
 130 } while(0)
 131
 132 /* Check whether rekey protocol is active */
 133 #define SILC_CLIENT_IS_REKEY(sock)                                      \
 134   (sock->protocol && sock->protocol->protocol &&                        \
 135    sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)
 136
 137 /* Prototypes */
 138
 139 SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process);
 140 int silc_client_packet_send_real(SilcClient client,
 141                                  SilcSocketConnection sock,
 142                                  bool force_send);
 143 void silc_client_ftp_free_sessions(SilcClient client,
 144                                    SilcClientConnection conn);
 145 void silc_client_ftp_session_free(SilcClientFtpSession session);
 146 void silc_client_ftp_session_free_client(SilcClientConnection conn,
 147                                          SilcClientEntry client_entry);
 148 void silc_client_packet_send(SilcClient client,
 149                              SilcSocketConnection sock,
 150                              SilcPacketType type,
 151                              void *dst_id,
 152                              SilcIdType dst_id_type,
 153                              SilcCipher cipher,
 154                              SilcHmac hmac,
 155                              unsigned char *data,
 156                              SilcUInt32 data_len,
 157                              int force_send);
 158 void silc_client_disconnected_by_server(SilcClient client,
 159                                         SilcSocketConnection sock,
 160                                         SilcBuffer message);
 161 void silc_client_error_by_server(SilcClient client,
 162                                  SilcSocketConnection sock,
 163                                  SilcBuffer message);
 164 void silc_client_receive_new_id(SilcClient client,
 165                                 SilcSocketConnection sock,
 166                                 SilcIDPayload idp);
 167 void silc_client_save_channel_key(SilcClient client,
 168                                   SilcClientConnection conn,
 169                                   SilcBuffer key_payload,
 170                                   SilcChannelEntry channel);
 171 void silc_client_receive_channel_key(SilcClient client,
 172                                      SilcSocketConnection sock,
 173                                      SilcBuffer packet);
 174 void silc_client_channel_message(SilcClient client,
 175                                  SilcSocketConnection sock,
 176                                  SilcPacketContext *packet);
 177 void silc_client_remove_from_channels(SilcClient client,
 178                                       SilcClientConnection conn,
 179                                       SilcClientEntry client_entry);
 180 void silc_client_replace_from_channels(SilcClient client,
 181                                        SilcClientConnection conn,
 182                                        SilcClientEntry old,
 183                                        SilcClientEntry newclient);
 184 void silc_client_process_failure(SilcClient client,
 185                                  SilcSocketConnection sock,
 186                                  SilcPacketContext *packet);
 187 void silc_client_key_agreement(SilcClient client,
 188                                SilcSocketConnection sock,
 189                                SilcPacketContext *packet);
 190 void silc_client_notify_by_server(SilcClient client,
 191                                   SilcSocketConnection sock,
 192                                   SilcPacketContext *packet);
 193 void silc_client_private_message(SilcClient client,
 194                                  SilcSocketConnection sock,
 195                                  SilcPacketContext *packet);
 196 void silc_client_connection_auth_request(SilcClient client,
 197                                          SilcSocketConnection sock,
 198                                          SilcPacketContext *packet);
 199 void silc_client_ftp(SilcClient client,
 200                      SilcSocketConnection sock,
 201                      SilcPacketContext *packet);
 202
 203 #endif