TODO

   1 TODO for 1.2 And Beyond
   2 =======================
   3
   4 NOTE: Any item that doesn't have (***DONE) in it, isn't done yet.  The
   5 (***TESTING NEEDED) means that the item has been done but not yet properly
   6 tested.
   7
   8 NOTE: A TODO entry does not mean that it is ever going to be done.  Some
   9 of the entries may be just ideas, good, bad or ugly.  If you want to work
  10 on some of the TODO entries simply let us know about it by dropping a note
  11 to silc-devel mailing list or appear on 'silc' channel on SILCNet.
  12
  13
  14 General
  15 =======
  16
  17  o Create apps/tutorial containing various Toolkit API tutorials.
  18
  19  o The Toolkit split.  The Toolkit is to be splitted in parts.  How many
  20    parts and what the parts are isn't decided yet.  Each part is a separate
  21    software package.  Current thinking is of the following:
  22
  23    SILC Toolkit                 SILC protocol, client and server library
  24    SILC Runtime Toolkit         runtime library
  25    SILC Crypto Toolkit          crypto, asn1, math, skr, pgp, etc.
  26
  27    The rationale for this is of course that other than SILC projects
  28    might like to use the various libraries SILC Toolkit provides, but
  29    naturally they don't want the bloat of SILC protocol related stuff.
  30
  31    The Runtime library in SILC Toolkit is a general purpose runtime library,
  32    like Glib and APR are.  The runtime library is to be developed further
  33    to provide alternative to Glib and APR.
  34
  35    The Crypto library in SILC Toolkit is a general purpose crypto library
  36    providing pretty nice APIs compared to many other crypto libraries,
  37    especially OpenSSL.  The Crypto library is to be developed further
  38    to include support for OpenPGP, X.509 and SSH2.
  39
  40
  41 lib/silccore
  42 ============
  43
  44  o SILC_PACKET_FLAG_ACK support.  Implement ACK packet and packet payload
  45    to silcpacket.c.
  46
  47  o All payload encoding routines should take SilcStack as argument.
  48
  49  o All payload test routines into lib/silccore/tests/.
  50
  51
  52 lib/silcclient, The Client Library
  53 ==================================
  54
  55  o peer-to-peer private messages
  56
  57  o Private message key request notification to application.  See XXX in
  58    client_prvmsg.c.
  59
  60  o in JOIN notify handle resolving that timedout.  Currently the user is
  61    never joined the channel if this happens.  What to do if message is
  62    received from user that hasn't been resolved/joined?
  63
  64  o Message ACKing support.
  65
  66  o in /cmode and /cumode with +r, maybe the public key and private key
  67    could be just some "string", which would then match to "string.pub" and
  68    "string.prv".
  69
  70
  71 Runtime library, lib/silcutil/
  72 ==============================
  73
  74  o Fix universal time decoding (doesn't accept all formats) in silctime.c.
  75
  76  o Add functions to manipulate environment variables.
  77
  78    SilcBool silc_setenv(const char *variable, const char *value);
  79    const char *silc_getenv(const char *variable);
  80    SilcBool silc_clearenv(const char *variable);
  81
  82  o Add functions to loading shared/dynamic object symbols (replaces the
  83    SIM library (lib/silcsim) and introduces generic library).  Add this
  84    to lib/silcutil/silcdll.[ch].
  85
  86    SilcDll silc_dll_load(const char *object_path, SilcDllFlags flags);
  87    void silc_dll_close(SilcDll dll);
  88    void *silc_dll_getsym(SilcDll dll, const char *symbol);
  89    const char *silc_dll_error(SilcDll dll);
  90
  91  o Add directory opening/traversing functions
  92
  93  o silc_getopt routines
  94
  95  o silc_hash_table_replace -> silc_hash_table_set.  Retain support for
  96    silc_hash_table_replace as macro.
  97
  98  o The SILC Event signals.  Asynchronous events that can be created,
  99    connected to and signalled.  Either own event routines or glued into
 100    SilcSchedule:
 101
 102    SilcTask silc_schedule_task_add_event(SilcSchedule schedule,
 103                                          const char *event, ...);
 104    SilcBool silc_schedule_event_connect(SilcSchedule schedule,
 105                                         const char *event,
 106                                         SilcTaskCallback event_callback,
 107                                         void *context);
 108    SilcBool silc_schedule_event_signal(SilcSchedule schedule,
 109                                        const char *event, ...);
 110
 111    Example:
 112      silc_schedule_task_add_event(schedule, "connected",
 113                                   SILC_PARAM_UI32_INT,
 114                                   SILC_PARAM_BUFFER,
 115                                   SILC_PARAM_END);
 116      silc_schedule_event_connect(schedule, "connected", connected_cb, ctx);
 117      silc_schedule_event_signal(schedule, "connected", integer, buf,
 118                                  SILC_PARAM_END);
 119      SILC_TASK_CALLBACK(connected_cb)
 120      {
 121        FooCtx ctx = context;
 122        va_list args;
 123        SilcUInt32 integer;
 124        SilcBuffer buf;
 125
 126        va_start(args, context);
 127        integer = va_arg(args, SilcUInt32);
 128        buf = va_arg(args, SilcBuffer);
 129        va_end(args);
 130        ...
 131      }
 132
 133    Problems: Events would be SilcSchedule specific, and would not work on
 134    multi-thread/multi-scheduler system.  The events should be copyable
 135    between schedulers.
 136
 137  o If the event signals are added, the SILC_PARAM_* stuff needs to be
 138    moved from silcbuffmt.h to silctypes.h or something similar.
 139
 140  o In case the SILC Events are done we shall create a new concept of
 141    parent and child SilcSchedule's.  When new SilcSchedule is created a
 142    parent can be associated to it.  This association could be done either
 143    directly by the parent or by any other children.  This way the signals
 144    would in effect be global and would reach all children schedulers.
 145
 146    This relationship would be associative only.  The schedulers are still
 147    independent and run independently from each other.   All schedulers
 148    would be linked and could be accessed from any of the schedulers.
 149    It should be possible to retrieve the parent and enumate all children
 150    from any of the schedulers.
 151
 152    SilcSchedule silc_schedule_init(int max_tasks, void *app_context,
 153                                    SilcSchedule parent);
 154    SilcSchedule silc_schedule_get_parent(SilcSchedule schedule);
 155
 156  o Structured log messages to Log API.  Allows machine readable log
 157    messages.  Would allow sending of any kind of data in a log message.
 158
 159  o Base64 to an own API
 160
 161  o Timer API
 162
 163  o Add builtin SOCKS and HTTP Proxy support, well the SOCKS at least.
 164    SILC currently supports SOCKS4 and SOCKS5 but it needs to be compiled
 165    in separately.
 166
 167  o silc_stringprep to non-allocating version.
 168
 169  o SilcStack aware SilcHashTable.
 170
 171  o SilcStack aware SilcDList.
 172
 173  o Thread pool API.  Add this to lib/silcutil/silcthread.[ch].
 174
 175    typedef void (*SilcThreadPoolFunc)(SilcSchedule schedule,
 176                                       void *context);
 177
 178    /* Allocate thread pool with at least `min_threads' and at most
 179       `max_threads' many threads.  If `stack' is non-NULL all memory
 180       is allocated from the `stack'.  If `start_min_threads' is TRUE
 181       this will start `min_threads' many threads immediately. */
 182    SilcThreadPool silc_thread_pool_alloc(SilcStack stack,
 183                                          SilcUInt32 min_threads,
 184                                          SilcUInt32 max_threads,
 185                                          SilcBool start_min_threads);
 186
 187    /* Free thread pool.  If `wait_unfinished' is TRUE this will block
 188       and waits that all remaining active threads finish before freeing
 189       the pool. */
 190    void silc_thread_pool_free(SilcThreadPool tp, SilcBool wait_unfinished);
 191
 192    /* Run `run' function with `run_context' in one of the threads in the
 193       thread pool.  Returns FALSE if the thread pool is being freed.  If
 194       there are no free threads left in the pool this will queue the
 195       the `run' and will call it once a thread becomes free.
 196
 197       If `completion' is non-NULL it will be called to indicate completion
 198       of the `run' function.  If `schedule' is non-NULL the `completion'
 199       will be called through the scheduler in the main thread.  If it is
 200       NULL the `completion' is called directly from the thread after the
 201       `run' has returned. */
 202    SilcBool silc_thread_pool_run(SilcThreadPool tp,
 203                                  SilcSchedule schedule,
 204                                  SilcThreadPoolFunc run,
 205                                  void *run_context,
 206                                  SilcThreadPoolFunc completion,
 207                                  void *completion_context);
 208
 209    /* Modify the amount of maximum threads of the pool. */
 210    void silc_thread_pool_set_max_threads(SilcThreadPool tp,
 211                                          SilcUInt32 max_threads);
 212
 213    /* Returns the amount of maximum size the pool can grow. */
 214    SilcUInt32 silc_thread_pool_num_max_threads(SilcThreadPool tp);
 215
 216    /* Returns the amount of free threads in the pool currently. */
 217    SilcUInt32 silc_thread_pool_num_free_threads(SilcThreadPool tp);
 218
 219    /* Stops all free and started threads.  The minumum amount of threads
 220       specified to silc_thread_pool_alloc always remains. */
 221    void silc_thread_pool_purge(SilcThreadPool tp);
 222
 223  o Fast mutex implementation.  Fast rwlock implementation.  Mutex and
 224    rwlock implementation using atomic operations.
 225
 226  o Compression routines are missing.  The protocol supports packet
 227    compression thus it must be implemented.  SILC Zip API must be
 228    defined.
 229
 230  (o Generic SilcStatus or SilcResult that includes all possible status and
 231     error conditions, including those of SILC protocol.  Though, the SILC
 232     protocol related status (currently in silcstatus.h) cannot be in
 233     runtime library) maybe
 234
 235  (o SILC specific socket creation/closing routines to silcnet.h, wrappers
 236   to all send(), recv(), sendto() etc.  Bad thing is that we'd have to
 237   define all socket options, sockaddrs, etc.) maybe
 238
 239  (o mmap) maybe
 240
 241
 242 lib/silcutil/symbian/
 243 =====================
 244
 245  o Something needs to be thought to the logging globals as well,
 246    like silc_debug etc.  They won't work on EPOC.  Perhaps logging
 247    and debugging is to be disabled on EPOC.  The logging currently works
 248    by it cannot be controlled, same with debugging.
 249
 250
 251 SFTP Library, lib/silcsftp/
 252 ===========================
 253
 254  o Read prefetch (read-ahead, reading ahead of time).  Maybe if this can
 255    be done easily.
 256
 257
 258 SKR Library, lib/silcskr/
 259 =========================
 260
 261  o Add fingerprint as search constraint.
 262
 263  o Add OpenPGP support.  Adding, removing, fetching PGP keys.  (Keyring
 264    support?)
 265
 266  o Add support for importing public keys from a directory and/or from a
 267    file.  Add support for exporting the repository (different formats for
 268    different key types?).
 269
 270  o Change the entire silc_skr_find API.  Remove SilcSKRFind and just simply
 271    add the find constraints as variable argument list to silc_skr_find, eg:
 272
 273   silc_skr_find(skr, schedule, callback, context,
 274                 SILC_SKR_FIND_PUBLIC_KEY, public_key,
 275                 SILC_SKR_FIND_COUNTRY, "FI",
 276                 SILC_SKR_FIND_USAGE, SILC_SKR_USAGE_AUTH,
 277                 SILC_SKR_FIND_END);
 278
 279    NULL argument would be ignored and skipped.
 280
 281  o Add OR logical rule in addition of the current default AND, eg:
 282
 283   // Found key(s) MUST have this public key AND this country.
 284   silc_skr_find(skr, schedule, callback, context,
 285                 SILC_SKR_FIND_RULE_AND,
 286                 SILC_SKR_FIND_PUBLIC_KEY, public_key,
 287                 SILC_SKR_FIND_COUNTRY, "FI",
 288                 SILC_SKR_FIND_END);
 289
 290   // Found key(s) MUST have this public key OR this key context
 291   silc_skr_find(skr, schedule, callback, context,
 292                 SILC_SKR_FIND_RULE_OR,
 293                 SILC_SKR_FIND_PUBLIC_KEY, public_key,
 294                 SILC_SKR_FIND_CONTEXT, key_context,
 295                 SILC_SKR_FIND_END);
 296
 297
 298 Crypto Library, lib/silccrypt/
 299 ==============================
 300
 301  o Add fingerprint to SilcSILCPublicKey and retrieval to silcpk.h, and
 302    possibly to silcpkcs.h.
 303
 304    /* Return fingerprint of the `public_key'.  Returns also the algorithm
 305       that has been used to make the fingerprint. */
 306    const unsigned char *
 307    silc_pkcs_get_fingerprint(SilcPublicKey public_key,
 308                              const char **hash_algorithm,
 309                              SilcUInt32 *fingerprint_len);
 310
 311  o Change SILC PKCS API to asynchronous, so that accelerators can be used.
 312    All PKCS routines should now take callbacks as argument and they should
 313    be delivered to SilcPKCSObject and SilcPKCSAlgorithm too.
 314
 315    /* Signature computation callback */
 316    typedef void (*SilcPKCSSignCb)(SilcBool success,
 317                                   const unsigned char *signature,
 318                                   SilcUInt32 signature_len,
 319                                   void *context);
 320
 321    /* Signature verification callback */
 322    typedef void (*SilcPKCSVerifyCb)(SilcBool success, void *context);
 323
 324    /* Encryption callback */
 325    typedef void (*SilcPKCSEncryptCb)(SilcBool success,
 326                                      const unsigned char *encrypted,
 327                                      SilcUInt32 encrypted_len,
 328                                      void *context);
 329
 330    /* Decryption callback */
 331    typedef void (*SilcPKCSDecryptCb)(SilcBool success,
 332                                      const unsigned char *decrypted,
 333                                      SilcUInt32 decrypted_len,
 334                                      void *context);
 335
 336    Either add new _async functions or add the callbacks to existing API
 337    and if the callback is NULL then the API is not async and if provided
 338    it may be async.  For example;
 339
 340    SilcBool silc_pkcs_sign(SilcPrivateKey private_key,
 341                            unsigned char *src, SilcUInt32 src_len,
 342                            unsigned char *dst, SilcUInt32 dst_size,
 343                            SilcUInt32 *dst_len,
 344                            SilcBool compute_hash, SilcHash hash,
 345                            SilcPKCSSignCb async_sign,
 346                            void *async_sign_context);
 347
 348    (if this is done then there's no reason why the buffers in the
 349     callbacks cannot be the ones user gives here) or allow only async:
 350
 351    SilcBool silc_pkcs_sign(SilcPrivateKey private_key,
 352                            unsigned char *src, SilcUInt32 src_len,
 353                            SilcBool compute_hash, SilcHash hash,
 354                            SilcPKCSSignCb async_sign,
 355                            void *async_sign_context);
 356
 357    or add new:
 358
 359    SilcBool silc_pkcs_sign_async(SilcPrivateKey private_key,
 360                                  unsigned char *src, SilcUInt32 src_len,
 361                                  SilcBool compute_hash, SilcHash hash,
 362                                  SilcPKCSSignCb async_sign,
 363                                  void *async_sign_context);
 364
 365  o Change PKCS Algorithm API to take SilcPKCSAlgorithm as argument to
 366    encrypt, decrypt, sign and verify functions.  We may need to for exmaple
 367    check the alg->hash, supported hash functions.  Maybe deliver it also
 368    to all other functions in SilcPKCSAlgorithm to be consistent.
 369
 370  o Add DSS support.  Take implementation from Tom or make it yourself.
 371
 372  o Implement the defined SilcDH API.  The definition is in
 373    lib/silccrypt/silcdh.h.  Make sure it is asynchronous so that it can
 374    be accelerated.  Also take into account that it could use elliptic
 375    curves.
 376
 377  o ECDSA and ECDH
 378
 379  o All cipher, hash, hmac etc. allocation routines should take their name
 380    in as const char * not const unsigned char *.
 381
 382
 383 SILC Accelerator Library
 384 ========================
 385
 386  o SILC Accelerator API.  Provides generic way to use different kind of
 387    accelerators.  Basically implements SILC PKCS API so that SilcPublicKey
 388    and SilcPrivateKey can be used but they call the accelerators.
 389
 390    Something in the lines of (preliminary):
 391
 392    /* Register accelerator to system.  Initializes the accelerator. */
 393       Varargs are optional accelerator specific init parameteres. */
 394    SilcBool silc_acc_register(SilcAccelerator acc, ...);
 395
 396      silc_acc_register(softacc, "min_threads", 2, "max_threads", 16, NULL);
 397
 398    /* Unregister accelerator.  Uninitializes the accelerator. */
 399    SilcBool silc_acc_unregister(const SilcAccelerator acc);
 400
 401    /* Return list of the registered accelerators */
 402    SilcDList silc_acc_get_supported(void);
 403
 404    /* Find existing accelerator.  `name' is accelerator's name. */
 405    SilcAccelerator silc_acc_find(const char *name);
 406
 407    /* Return accelerator's name */
 408    const char *silc_acc_get_name(SilcAccelerator acc);
 409
 410    /* Accelerate `public_key'.  Return accelerated public key. */
 411    SilcPublicKey silc_acc_public_key(SilcAccelerator acc,
 412                                      SilcPublicKey public_key);
 413
 414    /* Accelerate `private_key'.  Returns accelerated private key. */
 415    SilcPrivateKey silc_acc_private_key(SilcAccelerator acc,
 416                                        SilcPrivateKey private_key);
 417
 418    /* Return the underlaying public key */
 419    SilcPublicKey silc_acc_get_public_key(SilcAccelerator acc,
 420                                          SilcPublicKey public_key);
 421
 422    /* Return the underlaying private key */
 423    SilcPrivateKey silc_acc_get_private_key(SilcAccelerator acc,
 424                                            SilcPrivateKey private_key);
 425
 426    typedef struct SilcAcceleratorObject {
 427      const char *name;                  /* Accelerator's name */
 428      SilcBool (*init)(va_list va);      /* Initialize accelerator */
 429      SilcBool (*uninit)(void);          /* Uninitialize accelerator */
 430      const SilcPKCSAlgorithm *pkcs;     /* Accelerated PKCS algorithms */
 431      const SilcDHObject *dh;            /* Accelerated Diffie-Hellmans */
 432      const SilcCipherObject *cipher;    /* Accelerated ciphers */
 433      const SilcHashObject *hash;        /* Accelerated hashes */
 434      const SilcRngObject *rng;          /* Accelerated RNG's */
 435    } *SilcAccelerator, SilcAcceleratorStruct;
 436
 437    Allows accelerator to have multiple accelerators (cipher, hash etc)
 438    and multiple different algorithms and implementations (SHA-1, SHA-256 etc).
 439
 440    SilcPublicKey->SilcSILCPublicKey->RsaPublicKey accelerated as:
 441    SilcPublicKey->SilcAcceleratorPublicKey->SilcSoftAccPublicKey->
 442      SilcPublicKey->SilcSILCPublicKey->RsaPublicKey
 443
 444    silc_acc_public_key creates SilcPublicKey and SilcAcceleratorPublicKey
 445    and acc->pkcs->import_public_key creates SilcSoftAccPublicKey.
 446
 447  o Implement software accelerator.  It is a thread pool system where the
 448    public key and private key operations are executed in threads.
 449
 450    const struct SilcAcceleratorObject softacc =
 451    {
 452      "softacc", softacc_init, softacc_uninit,
 453      softacc_pkcs, NULL, NULL, NULL, NULL
 454    }
 455
 456    /* Called from silc_acc_private_key */
 457    int silc_softacc_import_private_key(void *key, SilcUInt32 key_len,
 458                                        void **ret_private_key)
 459    {
 460      SilcSoftAccPrivateKey prv = silc_calloc(1, sizeof(*prv));
 461      prv->pkcs = acc->pkcs;
 462      prv->private_key = key;
 463      *ret_private_key = prv;
 464    }
 465
 466  (o Symmetric key cryptosystem acceleration?  They are always sycnhronouos
 467    even with hardware acceleration so the crypto API shouldn't require
 468    changes.) maybe
 469
 470
 471 lib/silcmath
 472 ============
 473
 474  o Import TFM.  Talk to Tom to add the missing functions.  Use TFM in
 475    client and client library, but TMA in server, due to the significantly
 476    increased memory consumption with TFM, and the rare need for public
 477    key operations in server.
 478
 479    We want TFM's speed but not TFM's memory requirements.  Talk to Tom
 480    about making the TFM mp dynamic just as it is in LTM.
 481
 482  o The SILC MP API function must start returning indication of success
 483    and failure of the operation.
 484
 485  o Do SilcStack support for silc_mp_init, silc_mp_init_size and other
 486    any other MP function (including utility ones) that may allocate
 487    memory.
 488
 489  o All utility functions should be made non-allocating ones.
 490
 491
 492 SILC XML Library, lib/silcxml/
 493 ==============================
 494
 495  o SILC XML API (wrapper to expat).  The SILC XML API should follow and
 496    resemble Simple API for XML (SAX).
 497
 498
 499 lib/silcske/silcske.[ch]
 500 ========================
 501
 502  o Ratelimit to UDP/IP transport for incoming packets.
 503
 504
 505 lib/silcasn1
 506 ============
 507
 508  o Negative integer encoding is missing, add it.
 509
 510  o SILC_ASN1_CHOICE should perhaps return an index what choice in the
 511    choice list was found.  Currently it is left for caller to figure out
 512    which choice was found.
 513
 514  o SILC_ASN1_NULL in decoding should return SilcBool whether or not
 515    the NULL was present.  It's important when it's SILC_ASN1_OPTIONAL
 516    and we need to know whether it was present or not.
 517
 518
 519 lib/silcpgp
 520 ===========
 521
 522  o OpenPGP certificate support, allowing the use of PGP public keys
 523    in SILC.
 524
 525
 526 lib/silcssh
 527 ===========
 528
 529  o SSH2 public key/private key support, allowing the use of SSH2 keys
 530    in SILC.  RFC 4716.
 531
 532
 533 lib/silcpkix
 534 ============
 535
 536  o PKIX implementation
 537
 538
 539 lib/silcserver
 540 ==============
 541
 542  o (Re)write commands/command replys.
 543
 544  o (Re)write notify handling.
 545
 546  o The SERVER_SIGNOFF notify handing is not optimal, because it'll
 547    cause sending of multiple SIGNOFF notify's instead of the one
 548    SERVER_SIGNOFF notify that the server received.  This should be
 549    optimized so that the only SERVER_SIGNOFF is sent and not
 550    SIGNOFF of notify at all (using SIGNOFF takes the idea about
 551    SERVER_SIGNOFF away entirely).
 552
 553  o Another SERVER_SIGNOFF opt/bugfix:  Currently the signoff is
 554    sent to a client if it is on same channel as the client that
 555    signoffed.  However, the entire SERVER_SIGNOFF list is sent to
 556    the client, ie. it may receive clients that was not on the
 557    same channel.  This is actually against the specs.  It must be
 558    done per channel.  It shouldn't receive the whole list just
 559    because one client happened to be on same channel.
 560
 561  o Add reference counters to all Silc*Entry structures
 562
 563  o SERVICEs support (plugin, SIM)
 564
 565  o If client's public key is saved in the server (and doing public key
 566    authentication) then the hostname and the username information could
 567    be taken from the public key.  Should be a configuration option!
 568
 569  o Add a timeout to handling incoming JOIN commands.  It should be
 570    enforced that JOIN command is executed only once in a second or two
 571    seconds.  Now it is possible to accept n incoming JOIN commands
 572    and process them without any timeouts.  THis must be employed because
 573    each JOIN command will create and distribute the new channel key
 574    to everybody on the channel.
 575
 576  o Related to above.  If multiple JOINs are received in sequence perhaps
 577    new key should be created only once, if the JOINs are handeled at the same
 578    time.  Now we create multiple keys and never end up using them because
 579    many JOINs are processed at the same time in sequence.  Only the last
 580    key ends up being used.
 581
 582  o The CMODE cipher & hmac change problem (#101).