apps/silc/client_ops.c

   1 /*
   2
   3   client_ops.c
   4
   5   Author: Pekka Riikonen <priikone@poseidon.pspt.fi>
   6
   7   Copyright (C) 2000 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 #include "clientincludes.h"
  22
  23 /* Prints a message with three star (*) sign before the actual message
  24    on the current output window. This is used to print command outputs
  25    and error messages. */
  26
  27 void silc_say(SilcClient client, SilcClientConnection conn,
  28               char *msg, ...)
  29 {
  30   va_list vp;
  31   char message[2048];
  32   SilcClientInternal app = (SilcClientInternal)client->application;
  33
  34   memset(message, 0, sizeof(message));
  35   strncat(message, "\n***  ", 5);
  36
  37   va_start(vp, msg);
  38   vsprintf(message + 5, msg, vp);
  39   va_end(vp);
  40
  41   /* Print the message */
  42   silc_print_to_window(app->screen->output_win[0], message);
  43 }
  44
  45 /* Message for a channel. The `sender' is the nickname of the sender
  46    received in the packet. The `channel_name' is the name of the channel. */
  47
  48 void silc_channel_message(SilcClient client, SilcClientConnection conn,
  49                           char *sender, char *channel_name, char *msg)
  50 {
  51   /* Message from client */
  52   if (!strcmp(conn->current_channel->channel_name, channel_name))
  53     silc_print(client, "<%s> %s", sender, msg);
  54   else
  55     silc_print(client, "<%s:%s> %s", sender, channel_name, msg);
  56 }
  57
  58 /* Private message to the client. The `sender' is the nickname of the
  59    sender received in the packet. */
  60
  61 void silc_private_message(SilcClient client, SilcClientConnection conn,
  62                           char *sender, char *msg)
  63 {
  64   silc_print(client, "*%s* %s", sender, msg);
  65 }
  66
  67
  68 /* Notify message to the client. The notify arguments are sent in the
  69    same order as servers sends them. The arguments are same as received
  70    from the server except for ID's.  If ID is received application receives
  71    the corresponding entry to the ID. For example, if Client ID is received
  72    application receives SilcClientEntry.  Also, if the notify type is
  73    for channel the channel entry is sent to application (even if server
  74    does not send it). */
  75
  76 void silc_notify(SilcClient client, SilcClientConnection conn,
  77                  SilcNotifyType type, ...)
  78 {
  79   SilcClientInternal app = (SilcClientInternal)client->application;
  80   va_list vp;
  81   char message[4096];
  82   SilcClientEntry client_entry, client_entry2;
  83   SilcChannelEntry channel_entry;
  84   char *tmp;
  85   unsigned int tmp_int;
  86
  87   va_start(vp, type);
  88
  89   memset(message, 0, sizeof(message));
  90
  91   /* Get arguments (defined by protocol in silc-pp-01 -draft) */
  92   switch(type) {
  93   case SILC_NOTIFY_TYPE_NONE:
  94     tmp = va_arg(vp, char *);
  95     if (!tmp)
  96       return;
  97     strcpy(message, tmp);
  98     break;
  99
 100   case SILC_NOTIFY_TYPE_INVITE:
 101     client_entry = va_arg(vp, SilcClientEntry);
 102     channel_entry = va_arg(vp, SilcChannelEntry);
 103     snprintf(message, sizeof(message), "%s invites you to channel %s",
 104              client_entry->nickname, channel_entry->channel_name);
 105     break;
 106
 107   case SILC_NOTIFY_TYPE_JOIN:
 108     client_entry = va_arg(vp, SilcClientEntry);
 109     channel_entry = va_arg(vp, SilcChannelEntry);
 110     snprintf(message, sizeof(message), "%s (%s) has joined channel %s",
 111              client_entry->nickname, client_entry->username,
 112              channel_entry->channel_name);
 113     break;
 114
 115   case SILC_NOTIFY_TYPE_LEAVE:
 116     client_entry = va_arg(vp, SilcClientEntry);
 117     channel_entry = va_arg(vp, SilcChannelEntry);
 118     if (client_entry->server)
 119       snprintf(message, sizeof(message), "%s@%s has left channel %s",
 120                client_entry->nickname, client_entry->server,
 121                channel_entry->channel_name);
 122     else
 123       snprintf(message, sizeof(message), "%s has left channel %s",
 124                client_entry->nickname, channel_entry->channel_name);
 125     break;
 126
 127   case SILC_NOTIFY_TYPE_SIGNOFF:
 128     client_entry = va_arg(vp, SilcClientEntry);
 129     if (client_entry->server)
 130       snprintf(message, sizeof(message), "Signoff: %s@%s",
 131                client_entry->nickname, client_entry->server);
 132     else
 133       snprintf(message, sizeof(message), "Signoff: %s",
 134                client_entry->nickname);
 135     break;
 136
 137   case SILC_NOTIFY_TYPE_TOPIC_SET:
 138     client_entry = va_arg(vp, SilcClientEntry);
 139     tmp = va_arg(vp, char *);
 140     channel_entry = va_arg(vp, SilcChannelEntry);
 141     if (client_entry->server)
 142       snprintf(message, sizeof(message), "%s@%s set topic on %s: %s",
 143                client_entry->nickname, client_entry->server,
 144                channel_entry->channel_name, tmp);
 145     else
 146       snprintf(message, sizeof(message), "%s set topic on %s: %s",
 147                client_entry->nickname, channel_entry->channel_name, tmp);
 148     break;
 149
 150   case SILC_NOTIFY_TYPE_NICK_CHANGE:
 151     client_entry = va_arg(vp, SilcClientEntry);
 152     client_entry2 = va_arg(vp, SilcClientEntry);
 153     if (client_entry->server && client_entry2->server)
 154       snprintf(message, sizeof(message), "%s@%s is known as %s@%s",
 155                client_entry->nickname, client_entry->server,
 156                client_entry2->nickname, client_entry2->server);
 157     else
 158       snprintf(message, sizeof(message), "%s is known as %s",
 159                client_entry->nickname, client_entry2->nickname);
 160     break;
 161
 162   case SILC_NOTIFY_TYPE_CMODE_CHANGE:
 163     client_entry = va_arg(vp, SilcClientEntry);
 164     tmp = silc_client_chmode(va_arg(vp, unsigned int));
 165     channel_entry = va_arg(vp, SilcChannelEntry);
 166     if (tmp)
 167       snprintf(message, sizeof(message), "%s changed channel mode to +%s",
 168                client_entry->nickname, tmp);
 169     else
 170       snprintf(message, sizeof(message), "%s removed all channel modes",
 171                client_entry->nickname);
 172     if (app->screen->bottom_line->channel_mode)
 173       silc_free(app->screen->bottom_line->channel_mode);
 174     app->screen->bottom_line->channel_mode = tmp;
 175     silc_screen_print_bottom_line(app->screen, 0);
 176     break;
 177
 178   case SILC_NOTIFY_TYPE_CUMODE_CHANGE:
 179     client_entry = va_arg(vp, SilcClientEntry);
 180     tmp_int = va_arg(vp, unsigned int);
 181     tmp = silc_client_chumode(tmp_int);
 182     client_entry2 = va_arg(vp, SilcClientEntry);
 183     channel_entry = va_arg(vp, SilcChannelEntry);
 184     if (tmp)
 185       snprintf(message, sizeof(message), "%s changed %s mode to +%s",
 186                client_entry->nickname, client_entry2->nickname, tmp);
 187     else
 188       snprintf(message, sizeof(message), "%s removed %s modes",
 189                client_entry->nickname, client_entry2->nickname);
 190     if (client_entry2 == conn->local_entry) {
 191       if (app->screen->bottom_line->mode)
 192         silc_free(app->screen->bottom_line->mode);
 193       app->screen->bottom_line->mode = silc_client_chumode_char(tmp_int);
 194       silc_screen_print_bottom_line(app->screen, 0);
 195     }
 196     silc_free(tmp);
 197     break;
 198
 199   case SILC_NOTIFY_TYPE_MOTD:
 200     {
 201       char line[256];
 202       int i;
 203       tmp = va_arg(vp, unsigned char *);
 204
 205       i = 0;
 206       while(tmp[i] != 0) {
 207         if (tmp[i++] == '\n') {
 208           memset(line, 0, sizeof(line));
 209           strncat(line, tmp, i - 1);
 210           tmp += i;
 211
 212           silc_say(client, conn, "%s", line);
 213
 214           if (!strlen(tmp))
 215             break;
 216           i = 0;
 217         }
 218       }
 219     }
 220     return;
 221
 222   default:
 223     break;
 224   }
 225
 226   silc_print(client, "*** %s", message);
 227 }
 228
 229 /* Command handler. This function is called always in the command function.
 230    If error occurs it will be called as well. `conn' is the associated
 231    client connection. `cmd_context' is the command context that was
 232    originally sent to the command. `success' is FALSE if error occured
 233    during command. `command' is the command being processed. It must be
 234    noted that this is not reply from server. This is merely called just
 235    after application has called the command. Just to tell application
 236    that the command really was processed. */
 237
 238 void silc_command(SilcClient client, SilcClientConnection conn,
 239                   SilcClientCommandContext cmd_context, int success,
 240                   SilcCommand command)
 241 {
 242   SilcClientInternal app = (SilcClientInternal)client->application;
 243
 244   if (!success)
 245     return;
 246
 247   switch(command)
 248     {
 249     case SILC_COMMAND_QUIT:
 250       app->screen->bottom_line->channel = NULL;
 251       silc_screen_print_bottom_line(app->screen, 0);
 252       break;
 253
 254     case SILC_COMMAND_LEAVE:
 255 #if 0
 256       if (!strncmp(conn->current_channel->channel_name, name, strlen(name))) {
 257         app->screen->bottom_line->channel = NULL;
 258         silc_screen_print_bottom_line(app->screen, 0);
 259       }
 260 #endif
 261       break;
 262
 263     }
 264 }
 265
 266 /* Command reply handler. This function is called always in the command reply
 267    function. If error occurs it will be called as well. Normal scenario
 268    is that it will be called after the received command data has been parsed
 269    and processed. The function is used to pass the received command data to
 270    the application.
 271
 272    `conn' is the associated client connection. `cmd_payload' is the command
 273    payload data received from server and it can be ignored. It is provided
 274    if the application would like to re-parse the received command data,
 275    however, it must be noted that the data is parsed already by the library
 276    thus the payload can be ignored. `success' is FALSE if error occured.
 277    In this case arguments are not sent to the application. `command' is the
 278    command reply being processed. The function has variable argument list
 279    and each command defines the number and type of arguments it passes to the
 280    application (on error they are not sent). */
 281
 282 void silc_command_reply(SilcClient client, SilcClientConnection conn,
 283                         SilcCommandPayload cmd_payload, int success,
 284                         SilcCommand command, SilcCommandStatus status, ...)
 285 {
 286   SilcClientInternal app = (SilcClientInternal)client->application;
 287   va_list vp;
 288   int i;
 289
 290   if (!success)
 291     return;
 292
 293   va_start(vp, status);
 294
 295   switch(command)
 296     {
 297
 298     case SILC_COMMAND_JOIN:
 299       {
 300         unsigned int mode;
 301
 302         app->screen->bottom_line->channel = va_arg(vp, char *);
 303         (void)va_arg(vp, void *);
 304         mode = va_arg(vp, unsigned int);
 305         app->screen->bottom_line->channel_mode = silc_client_chmode(mode);
 306         silc_screen_print_bottom_line(app->screen, 0);
 307       }
 308       break;
 309
 310     case SILC_COMMAND_NICK:
 311       {
 312         SilcClientEntry entry;
 313
 314         entry = va_arg(vp, SilcClientEntry);
 315         silc_say(client, conn, "Your current nickname is %s", entry->nickname);
 316         app->screen->bottom_line->nickname = entry->nickname;
 317         silc_screen_print_bottom_line(app->screen, 0);
 318       }
 319       break;
 320
 321     case SILC_COMMAND_NAMES:
 322       for (i = 0; i < conn->current_channel->clients_count; i++)
 323         if (conn->current_channel->clients[i].client == conn->local_entry) {
 324           if (app->screen->bottom_line->mode)
 325             silc_free(app->screen->bottom_line->mode);
 326           app->screen->bottom_line->mode =
 327             silc_client_chumode_char(conn->current_channel->clients[i].mode);
 328           silc_screen_print_bottom_line(app->screen, 0);
 329           break;
 330         }
 331       break;
 332     }
 333 }
 334
 335 /* Called to indicate that connection was either successfully established
 336    or connecting failed.  This is also the first time application receives
 337    the SilcClientConnection objecet which it should save somewhere. */
 338
 339 void silc_connect(SilcClient client, SilcClientConnection conn, int success)
 340 {
 341   SilcClientInternal app = (SilcClientInternal)client->application;
 342
 343   if (success) {
 344     app->screen->bottom_line->connection = conn->remote_host;
 345     silc_screen_print_bottom_line(app->screen, 0);
 346     app->conn = conn;
 347   }
 348 }
 349
 350 /* Called to indicate that connection was disconnected to the server. */
 351
 352 void silc_disconnect(SilcClient client, SilcClientConnection conn)
 353 {
 354   SilcClientInternal app = (SilcClientInternal)client->application;
 355
 356   app->screen->bottom_line->connection = NULL;
 357   silc_screen_print_bottom_line(app->screen, 0);
 358 }
 359
 360 /* Asks passphrase from user on the input line. */
 361
 362 unsigned char *silc_ask_passphrase(SilcClient client,
 363                                    SilcClientConnection conn)
 364 {
 365   SilcClientInternal app = (SilcClientInternal)conn->client->application;
 366   char pass1[256], pass2[256];
 367   char *ret;
 368   int try = 3;
 369
 370   while(try) {
 371
 372     /* Print prompt */
 373     wattroff(app->screen->input_win, A_INVIS);
 374     silc_screen_input_print_prompt(app->screen, "Passphrase: ");
 375     wattron(app->screen->input_win, A_INVIS);
 376
 377     /* Get string */
 378     memset(pass1, 0, sizeof(pass1));
 379     wgetnstr(app->screen->input_win, pass1, sizeof(pass1));
 380
 381     /* Print retype prompt */
 382     wattroff(app->screen->input_win, A_INVIS);
 383     silc_screen_input_print_prompt(app->screen, "Retype passphrase: ");
 384     wattron(app->screen->input_win, A_INVIS);
 385
 386     /* Get string */
 387     memset(pass2, 0, sizeof(pass2));
 388     wgetnstr(app->screen->input_win, pass2, sizeof(pass2));
 389
 390     if (!strncmp(pass1, pass2, strlen(pass2)))
 391       break;
 392
 393     try--;
 394   }
 395
 396   ret = silc_calloc(strlen(pass1), sizeof(char));
 397   memcpy(ret, pass1, strlen(pass1));
 398
 399   memset(pass1, 0, sizeof(pass1));
 400   memset(pass2, 0, sizeof(pass2));
 401
 402   wattroff(app->screen->input_win, A_INVIS);
 403   silc_screen_input_reset(app->screen);
 404
 405   return ret;
 406 }
 407
 408 /* Verifies received public key. If user decides to trust the key it is
 409    saved as trusted server key for later use. If user does not trust the
 410    key this returns FALSE. */
 411
 412 int silc_verify_server_key(SilcClient client,
 413                            SilcClientConnection conn,
 414                            unsigned char *pk, unsigned int pk_len,
 415                            SilcSKEPKType pk_type)
 416 {
 417   SilcSocketConnection sock = conn->sock;
 418   char filename[256];
 419   char file[256];
 420   char *hostname, *fingerprint;
 421   struct passwd *pw;
 422   struct stat st;
 423
 424   hostname = sock->hostname ? sock->hostname : sock->ip;
 425
 426   if (pk_type != SILC_SKE_PK_TYPE_SILC) {
 427     silc_say(client, conn, "We don't support server %s key type", hostname);
 428     return FALSE;
 429   }
 430
 431   pw = getpwuid(getuid());
 432   if (!pw)
 433     return FALSE;
 434
 435   memset(filename, 0, sizeof(filename));
 436   memset(file, 0, sizeof(file));
 437   snprintf(file, sizeof(file) - 1, "serverkey_%s_%d.pub", hostname,
 438            sock->port);
 439   snprintf(filename, sizeof(filename) - 1, "%s/.silc/serverkeys/%s",
 440            pw->pw_dir, file);
 441
 442   /* Check wheter this key already exists */
 443   if (stat(filename, &st) < 0) {
 444
 445     fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
 446     silc_say(client, conn, "Received server %s public key", hostname);
 447     silc_say(client, conn, "Fingerprint for the server %s key is", hostname);
 448     silc_say(client, conn, "%s", fingerprint);
 449     silc_free(fingerprint);
 450
 451     /* Ask user to verify the key and save it */
 452     if (silc_client_ask_yes_no(client,
 453        "Would you like to accept the key (y/n)? "))
 454       {
 455         /* Save the key for future checking */
 456         silc_pkcs_save_public_key_data(filename, pk, pk_len,
 457                                        SILC_PKCS_FILE_PEM);
 458         return TRUE;
 459       }
 460   } else {
 461     /* The key already exists, verify it. */
 462     SilcPublicKey public_key;
 463     unsigned char *encpk;
 464     unsigned int encpk_len;
 465
 466     /* Load the key file */
 467     if (!silc_pkcs_load_public_key(filename, &public_key,
 468                                    SILC_PKCS_FILE_PEM))
 469       if (!silc_pkcs_load_public_key(filename, &public_key,
 470                                      SILC_PKCS_FILE_BIN)) {
 471         fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
 472         silc_say(client, conn, "Received server %s public key", hostname);
 473         silc_say(client, conn, "Fingerprint for the server %s key is", hostname);
 474         silc_say(client, conn, "%s", fingerprint);
 475         silc_free(fingerprint);
 476         silc_say(client, conn, "Could not load your local copy of the server %s key",
 477                  hostname);
 478         if (silc_client_ask_yes_no(client,
 479            "Would you like to accept the key anyway (y/n)? "))
 480           {
 481             /* Save the key for future checking */
 482             unlink(filename);
 483             silc_pkcs_save_public_key_data(filename, pk, pk_len,
 484                                            SILC_PKCS_FILE_PEM);
 485             return TRUE;
 486           }
 487
 488         return FALSE;
 489       }
 490
 491     /* Encode the key data */
 492     encpk = silc_pkcs_public_key_encode(public_key, &encpk_len);
 493     if (!encpk) {
 494       fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
 495       silc_say(client, conn, "Received server %s public key", hostname);
 496       silc_say(client, conn, "Fingerprint for the server %s key is", hostname);
 497       silc_say(client, conn, "%s", fingerprint);
 498       silc_free(fingerprint);
 499       silc_say(client, conn, "Your local copy of the server %s key is malformed",
 500                hostname);
 501       if (silc_client_ask_yes_no(client,
 502          "Would you like to accept the key anyway (y/n)? "))
 503         {
 504           /* Save the key for future checking */
 505           unlink(filename);
 506           silc_pkcs_save_public_key_data(filename, pk, pk_len,
 507                                          SILC_PKCS_FILE_PEM);
 508           return TRUE;
 509         }
 510
 511       return FALSE;
 512     }
 513
 514     if (memcmp(encpk, pk, encpk_len)) {
 515       fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
 516       silc_say(client, conn, "Received server %s public key", hostname);
 517       silc_say(client, conn, "Fingerprint for the server %s key is", hostname);
 518       silc_say(client, conn, "%s", fingerprint);
 519       silc_free(fingerprint);
 520       silc_say(client, conn, "Server %s key does not match with your local copy",
 521                hostname);
 522       silc_say(client, conn, "It is possible that the key has expired or changed");
 523       silc_say(client, conn, "It is also possible that some one is performing "
 524                        "man-in-the-middle attack");
 525
 526       /* Ask user to verify the key and save it */
 527       if (silc_client_ask_yes_no(client,
 528          "Would you like to accept the key anyway (y/n)? "))
 529         {
 530           /* Save the key for future checking */
 531           unlink(filename);
 532           silc_pkcs_save_public_key_data(filename, pk, pk_len,
 533                                          SILC_PKCS_FILE_PEM);
 534           return TRUE;
 535         }
 536
 537       silc_say(client, conn, "Will not accept server %s key", hostname);
 538       return FALSE;
 539     }
 540
 541     /* Local copy matched */
 542     return TRUE;
 543   }
 544
 545   silc_say(client, conn, "Will not accept server %s key", hostname);
 546   return FALSE;
 547 }
 548
 549 /* Find authentication method and authentication data by hostname and
 550    port. The hostname may be IP address as well. The found authentication
 551    method and authentication data is returned to `auth_meth', `auth_data'
 552    and `auth_data_len'. The function returns TRUE if authentication method
 553    is found and FALSE if not. `conn' may be NULL. */
 554
 555 int silc_get_auth_method(SilcClient client, SilcClientConnection conn,
 556                          char *hostname, unsigned short port,
 557                          SilcProtocolAuthMeth *auth_meth,
 558                          unsigned char **auth_data,
 559                          unsigned int *auth_data_len)
 560 {
 561   SilcClientInternal app = (SilcClientInternal)client->application;
 562
 563   if (app->config->conns) {
 564     SilcClientConfigSectionConnection *conn = NULL;
 565
 566     /* Check if we find a match from user configured connections */
 567     conn = silc_client_config_find_connection(app->config,
 568                                               hostname,
 569                                               port);
 570     if (conn) {
 571       /* Match found. Use the configured authentication method */
 572       *auth_meth = conn->auth_meth;
 573
 574       if (conn->auth_data) {
 575         *auth_data = strdup(conn->auth_data);
 576         *auth_data_len = strlen(conn->auth_data);
 577       }
 578
 579       return TRUE;
 580     }
 581   }
 582
 583   return FALSE;
 584 }
 585
 586 /* Notifies application that failure packet was received.  This is called
 587    if there is some protocol active in the client.  The `protocol' is the
 588    protocol context.  The `failure' is opaque pointer to the failure
 589    indication.  Note, that the `failure' is protocol dependant and application
 590    must explicitly cast it to correct type.  Usually `failure' is 32 bit
 591    failure type (see protocol specs for all protocol failure types). */
 592
 593 void silc_failure(SilcClient client, SilcClientConnection conn,
 594                   SilcProtocol protocol, void *failure)
 595 {
 596   SilcClientInternal app = (SilcClientInternal)client->application;
 597
 598 }
 599
 600 /* SILC client operations */
 601 SilcClientOperations ops = {
 602   say:                  silc_say,
 603   channel_message:      silc_channel_message,
 604   private_message:      silc_private_message,
 605   notify:               silc_notify,
 606   command:              silc_command,
 607   command_reply:        silc_command_reply,
 608   connect:              silc_connect,
 609   disconnect:           silc_disconnect,
 610   get_auth_method:      silc_get_auth_method,
 611   verify_server_key:    silc_verify_server_key,
 612   ask_passphrase:       silc_ask_passphrase,
 613   failure:              silc_failure,
 614 };