X-Git-Url: http://git.silcnet.org/gitweb/?a=blobdiff_plain;f=lib%2Fsilcapputil%2Fsilcapputil.c;h=32018654de19f937f2c002935f91b0fd745f95a8;hb=9905799a86c606304fd7df2cd401de1740a272a1;hp=fe0ae5400d5e76c3207c63d93b8fc4d48ae6ad4c;hpb=ebfae3bbce6fed0dece516307f537ce5e270e7e0;p=silc.git

diff --git a/lib/silcapputil/silcapputil.c b/lib/silcapputil/silcapputil.c
index fe0ae540..32018654 100644
--- a/lib/silcapputil/silcapputil.c
+++ b/lib/silcapputil/silcapputil.c
@@ -40,7 +40,7 @@ static char *silc_create_pk_identifier(void)
     return NULL;
 
   /* Create default email address, whether it is right or not */
-  snprintf(email, sizeof(email), "%s@%s", username, hostname);
+  silc_snprintf(email, sizeof(email), "%s@%s", username, hostname);
 
   ident = silc_pkcs_silc_encode_identifier(username, hostname, realname,
 					   email, NULL, NULL);
@@ -71,6 +71,8 @@ SilcBool silc_create_key_pair(const char *pkcs_name,
   char *alg = pkcs_name ? strdup(pkcs_name) : NULL;
   char *identifier = pub_identifier ? strdup(pub_identifier) : NULL;
   char *pass = passphrase ? strdup(passphrase) : NULL;
+  SilcPublicKey public_key;
+  SilcPrivateKey private_key;
 
   if (interactive && (!alg || !pub_filename || !prv_filename))
     printf("\
@@ -121,9 +123,9 @@ New pair of keys will be created.  Please, answer to following questions.\n\
     if (interactive) {
       memset(line, 0, sizeof(line));
       if (def)
-	snprintf(line, sizeof(line), "Identifier [%s]: ", def);
+	silc_snprintf(line, sizeof(line), "Identifier [%s]: ", def);
       else
-	snprintf(line, sizeof(line),
+	silc_snprintf(line, sizeof(line),
 	       "Identifier (eg. UN=jon, HN=jon.dummy.com, "
 	       "RN=Jon Johnson, E=jon@dummy.com): ");
 
@@ -151,7 +153,7 @@ New pair of keys will be created.  Please, answer to following questions.\n\
   if (!pkfile) {
     if (interactive) {
       memset(line, 0, sizeof(line));
-      snprintf(line, sizeof(line), "Public key filename [public_key.pub]: ");
+      silc_snprintf(line, sizeof(line), "Public key filename [public_key.pub]: ");
       pkfile = silc_get_input(line, FALSE);
     }
     if (!pkfile)
@@ -161,7 +163,7 @@ New pair of keys will be created.  Please, answer to following questions.\n\
   if (!prvfile) {
     if (interactive) {
       memset(line, 0, sizeof(line));
-      snprintf(line, sizeof(line), "Private key filename [private_key.prv]: ");
+      silc_snprintf(line, sizeof(line), "Private key filename [private_key.prv]: ");
       prvfile = silc_get_input(line, FALSE);
     }
     if (!prvfile)
@@ -192,18 +194,28 @@ New pair of keys will be created.  Please, answer to following questions.\n\
 
   /* Generate keys */
   if (!silc_pkcs_silc_generate_key(alg, "pkcs1-no-oid", key_len_bits,
-				   identifier, rng, return_public_key,
-				   return_private_key))
+				   identifier, rng, &public_key,
+				   &private_key))
     return FALSE;
 
   /* Save public key into file */
-  silc_pkcs_save_public_key(pkfile, *return_public_key, SILC_PKCS_FILE_BASE64);
+  silc_pkcs_save_public_key(pkfile, public_key, SILC_PKCS_FILE_BASE64);
 
   /* Save private key into file */
-  silc_pkcs_save_private_key(prvfile, *return_private_key,
+  silc_pkcs_save_private_key(prvfile, private_key,
 			     (const unsigned char *)pass, strlen(pass),
 			     SILC_PKCS_FILE_BIN, rng);
 
+  if (return_public_key)
+    *return_public_key = public_key;
+  else
+    silc_pkcs_public_key_free(public_key);
+
+  if (return_private_key)
+    *return_private_key = private_key;
+  else
+    silc_pkcs_private_key_free(private_key);
+
   printf("Public key has been saved into `%s'.\n", pkfile);
   printf("Private key has been saved into `%s'.\n", prvfile);
   if (interactive) {
@@ -262,9 +274,8 @@ SilcBool silc_load_key_pair(const char *pub_filename,
 
 /* Dump public key into stdout */
 
-SilcBool silc_show_public_key(const char *pub_filename)
+SilcBool silc_show_public_key(SilcPublicKey public_key)
 {
-  SilcPublicKey public_key;
   SilcSILCPublicKey silc_pubkey;
   SilcPublicKeyIdentifier ident;
   char *fingerprint, *babbleprint;
@@ -272,11 +283,6 @@ SilcBool silc_show_public_key(const char *pub_filename)
   SilcUInt32 pk_len;
   SilcUInt32 key_len = 0;
 
-  if (!silc_pkcs_load_public_key((char *)pub_filename, &public_key)) {
-    fprintf(stderr, "Could not load public key file `%s'\n", pub_filename);
-    return FALSE;
-  }
-
   silc_pubkey = silc_pkcs_get_context(SILC_PKCS_SILC, public_key);
   if (!silc_pubkey) {
     silc_pkcs_public_key_free(public_key);
@@ -293,7 +299,6 @@ SilcBool silc_show_public_key(const char *pub_filename)
   fingerprint = silc_hash_fingerprint(NULL, pk, pk_len);
   babbleprint = silc_hash_babbleprint(NULL, pk, pk_len);
 
-  printf("Public key file    : %s\n", pub_filename);
   printf("Algorithm          : %s\n", silc_pkcs_get_name(public_key));
   if (key_len)
     printf("Key length (bits)  : %d\n", (unsigned int)key_len);
@@ -317,11 +322,29 @@ SilcBool silc_show_public_key(const char *pub_filename)
   silc_free(fingerprint);
   silc_free(babbleprint);
   silc_free(pk);
-  silc_pkcs_public_key_free(public_key);
 
   return TRUE;
 }
 
+/* Dump public key into stdout */
+
+SilcBool silc_show_public_key_file(const char *pub_filename)
+{
+  SilcPublicKey public_key;
+  SilcBool ret;
+
+  if (!silc_pkcs_load_public_key((char *)pub_filename, &public_key)) {
+    fprintf(stderr, "Could not load public key file `%s'\n", pub_filename);
+    return FALSE;
+  }
+
+  printf("Public key file    : %s\n", pub_filename);
+  ret = silc_show_public_key(public_key);
+  silc_pkcs_public_key_free(public_key);
+
+  return ret;
+}
+
 /* Change private key passphrase */
 
 SilcBool silc_change_private_key_passphrase(const char *prv_filename,
@@ -509,3 +532,532 @@ SilcBool silc_channel_name_verify(const unsigned char *identifier,
 
   return TRUE;
 }
+
+/* Return mode list */
+
+SilcBool silc_get_mode_list(SilcBuffer mode_list, SilcUInt32 mode_list_count,
+			    SilcUInt32 **list)
+{
+  int i;
+
+  if (silc_buffer_len(mode_list) / 4 != mode_list_count)
+    return FALSE;
+
+  *list = silc_calloc(mode_list_count, sizeof(**list));
+
+  for (i = 0; i < mode_list_count; i++) {
+    SILC_GET32_MSB((*list)[i], mode_list->data);
+    silc_buffer_pull(mode_list, 4);
+  }
+
+  silc_buffer_push(mode_list, mode_list->data - mode_list->head);
+
+  return TRUE;
+}
+
+/* Status message structure. Messages are defined below. */
+typedef struct {
+  SilcStatus status;
+  const char *message;
+} SilcStatusMessage;
+
+#define STAT(x) SILC_STATUS_ERR_##x
+static const SilcStatusMessage silc_status_messages[] = {
+
+  { STAT(NO_SUCH_NICK),      "There was no such nickname" },
+  { STAT(NO_SUCH_CHANNEL),   "There was no such channel" },
+  { STAT(NO_SUCH_SERVER),    "There was no such server" },
+  { STAT(INCOMPLETE_INFORMATION),  "Incomplete registration information" },
+  { STAT(NO_RECIPIENT),      "No recipient given" },
+  { STAT(UNKNOWN_COMMAND),   "Unknown command" },
+  { STAT(WILDCARDS),         "Wilcrads not allowed" },
+  { STAT(NO_CLIENT_ID),      "No Client ID given" },
+  { STAT(NO_CHANNEL_ID),     "No Channel ID given" },
+  { STAT(NO_SERVER_ID),      "No Server ID given" },
+  { STAT(BAD_CLIENT_ID),     "Bad Client ID" },
+  { STAT(BAD_CHANNEL_ID),    "Bad Channel ID" },
+  { STAT(NO_SUCH_CLIENT_ID), "There is no such client" },
+  { STAT(NO_SUCH_CHANNEL_ID),"There is no such channel" },
+  { STAT(NICKNAME_IN_USE),   "Nickname already exists" },
+  { STAT(NOT_ON_CHANNEL),    "You are not on that channel" },
+  { STAT(USER_NOT_ON_CHANNEL),"They are not on the channel" },
+  { STAT(USER_ON_CHANNEL),   "User already on the channel" },
+  { STAT(NOT_REGISTERED),    "You have not registered" },
+  { STAT(NOT_ENOUGH_PARAMS), "Not enough parameters" },
+  { STAT(TOO_MANY_PARAMS),   "Too many parameters" },
+  { STAT(PERM_DENIED),       "Permission denied" },
+  { STAT(BANNED_FROM_SERVER),"You are not allowed to connect" },
+  { STAT(BAD_PASSWORD),      "Cannot join channel. Incorrect password" },
+  { STAT(CHANNEL_IS_FULL),   "Cannot join channel. Channel is full" },
+  { STAT(NOT_INVITED),     "Cannot join channel. You have not been invited" },
+  { STAT(BANNED_FROM_CHANNEL), "Cannot join channel. You have been banned" },
+  { STAT(UNKNOWN_MODE),    "Unknown mode" },
+  { STAT(NOT_YOU),         "Cannot change mode for other users" },
+  { STAT(NO_CHANNEL_PRIV), "Permission denied. You are not channel operator" },
+  { STAT(NO_CHANNEL_FOPRIV),"Permission denied. You are not channel founder" },
+  { STAT(NO_SERVER_PRIV),  "Permission denied. You are not server operator" },
+  { STAT(NO_ROUTER_PRIV),  "Permission denied. You are not SILC operator" },
+  { STAT(BAD_NICKNAME),    "Bad nickname" },
+  { STAT(BAD_CHANNEL),     "Bad channel name" },
+  { STAT(AUTH_FAILED),     "Authentication failed" },
+  { STAT(UNKNOWN_ALGORITHM), "Unsupported algorithm" },
+  { STAT(NO_SUCH_SERVER_ID), "No such Server ID" },
+  { STAT(RESOURCE_LIMIT), "No more free resources" },
+  { STAT(NO_SUCH_SERVICE), "Service doesn't exist" },
+  { STAT(NOT_AUTHENTICATED), "You have not been authenticated" },
+  { STAT(BAD_SERVER_ID), "Server ID is not valid" },
+  { STAT(KEY_EXCHANGE_FAILED), "Key exchange failed" },
+  { STAT(BAD_VERSION), "Bad version" },
+  { STAT(TIMEDOUT), "Service timed out" },
+  { STAT(UNSUPPORTED_PUBLIC_KEY), "Unsupported public key type" },
+  { STAT(OPERATION_ALLOWED), "Operation is not allowed" },
+  { STAT(BAD_SERVER), "Bad server name" },
+  { STAT(BAD_USERNAME), "Bad user name" },
+
+  { 0, NULL }
+};
+
+/* Returns status message string */
+
+const char *silc_get_status_message(unsigned char status)
+{
+  int i;
+
+  for (i = 0; silc_status_messages[i].message; i++) {
+    if (silc_status_messages[i].status == status)
+      break;
+  }
+
+  if (silc_status_messages[i].message == NULL)
+    return "";
+
+  return silc_status_messages[i].message;
+}
+
+static const char *packet_name[] = {
+  "NONE",
+  "DISCONNECT",
+  "SUCCESS",
+  "FAILURE",
+  "REJECT",
+  "NOTIFY",
+  "ERROR",
+  "CHANNEL MESSAGE",
+  "CHANNEL KEY",
+  "PRIVATE MESSAGE",
+  "PRIVATE MESSAGE KEY",
+  "COMMAND",
+  "COMMAND REPLY",
+  "KEY EXCHANGE",
+  "KEY EXCHANGE 1",
+  "KEY EXCHANGE 2",
+  "CONNECTION AUTH REQUEST",
+  "CONNECTION AUTH",
+  "NEW ID",
+  "NEW CLIENT",
+  "NEW SERVER",
+  "NEW CHANNEL",
+  "REKEY",
+  "REKEY_DONE",
+  "HEARTBEAT",
+  "KEY AGREEMENT",
+  "RESUME ROUTER",
+  "FTP",
+  "RESUME CLIENT",
+};
+
+/* Returns packet type name */
+
+const char *silc_get_packet_name(unsigned char type)
+{
+  if (type >= SILC_PACKET_MAX)
+    return "RESERVED";
+  if (type >= SILC_PACKET_PRIVATE)
+    return "PRIVATE RANGE";
+  if (type > (sizeof(packet_name) / sizeof(*packet_name)))
+    return "UNKNOWN";
+  return packet_name[type];
+}
+
+static const char *command_name[] = {
+  "NONE",
+  "WHOIS",
+  "WHOWAS",
+  "IDENTIFY",
+  "NICK",
+  "LIST",
+  "TOPIC",
+  "INVITE",
+  "QUIT",
+  "KILL",
+  "INFO",
+  "STATS",
+  "PING",
+  "OPER",
+  "JOIN",
+  "MOTD",
+  "UMODE",
+  "CMODE",
+  "CUMODE",
+  "KICK",
+  "BAN",
+  "DETACH",
+  "WATCH",
+  "SILCOPER",
+  "LEAVE",
+  "USERS",
+  "GETKEY",
+  "SERVICE",
+};
+
+/* Returns command name */
+
+const char *silc_get_command_name(unsigned char command)
+{
+  if (command >= SILC_COMMAND_RESERVED)
+    return "RESERVED";
+  if (command >= SILC_COMMAND_PRIVATE)
+    return "PRIVATE RANGE";
+  if (command > (sizeof(command_name) / sizeof(*command_name)))
+    return "UNKNOWN";
+  return command_name[command];
+}
+
+/* Parses SILC protocol style version string. */
+
+SilcBool silc_parse_version_string(const char *version,
+				   SilcUInt32 *protocol_version,
+				   char **protocol_version_string,
+				   SilcUInt32 *software_version,
+				   char **software_version_string,
+				   char **vendor_version)
+{
+  char *cp, buf[32];
+  int maj = 0, min = 0;
+
+  if (!strstr(version, "SILC-"))
+    return FALSE;
+
+  cp = (char *)version + 5;
+  if (!cp)
+    return FALSE;
+
+  /* Take protocol version */
+
+  maj = atoi(cp);
+  if (!strchr(cp, '.'))
+    return FALSE;
+  cp = strchr(cp, '.') + 1;
+  if (!cp || !(*cp))
+    return FALSE;
+  min = atoi(cp);
+
+  memset(buf, 0, sizeof(buf));
+  silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+  if (protocol_version)
+    *protocol_version = atoi(buf);
+  memset(buf, 0, sizeof(buf));
+  silc_snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
+  if (protocol_version_string)
+    *protocol_version_string = strdup(buf);
+
+  /* Take software version */
+
+  maj = 0;
+  min = 0;
+  if (!strchr(cp, '-'))
+    return FALSE;
+  cp = strchr(cp, '-') + 1;
+  if (!cp || !(*cp))
+    return FALSE;
+
+  maj = atoi(cp);
+  if (strchr(cp, '.')) {
+    cp = strchr(cp, '.') + 1;
+    if (cp && *cp)
+      min = atoi(cp);
+  }
+
+  memset(buf, 0, sizeof(buf));
+  silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+  if (software_version)
+    *software_version = atoi(buf);
+  memset(buf, 0, sizeof(buf));
+  silc_snprintf(buf, sizeof(buf) - 1, "%d.%d", maj, min);
+  if (software_version_string)
+    *software_version_string = strdup(buf);
+
+  /* Take vendor string */
+
+  if (strchr(cp, '.')) {
+    cp = strchr(cp, '.') + 1;
+    if (cp && *cp && vendor_version)
+      *vendor_version = strdup(cp);
+  }
+
+  return TRUE;
+}
+
+/* Converts version string x.x into number representation. */
+
+SilcUInt32 silc_version_to_num(const char *version)
+{
+  int maj = 0, min = 0;
+  char *cp, buf[32];
+
+  if (!version)
+    return 0;
+
+  cp = (char *)version;
+  maj = atoi(cp);
+  cp = strchr(cp, '.');
+  if (cp)
+    min = atoi(cp + 1);
+
+  memset(buf, 0, sizeof(buf));
+  silc_snprintf(buf, sizeof(buf) - 1, "%d%d", maj, min);
+  return (SilcUInt32)atoi(buf);
+}
+
+/* Parses mode mask and returns the mode as string. */
+
+char *silc_client_chmode(SilcUInt32 mode, const char *cipher, const char *hmac)
+{
+  char string[100];
+
+  if (!mode)
+    return NULL;
+
+  memset(string, 0, sizeof(string));
+
+  if (mode & SILC_CHANNEL_MODE_PRIVATE)
+    strncat(string, "p", 1);
+
+  if (mode & SILC_CHANNEL_MODE_SECRET)
+    strncat(string, "s", 1);
+
+  if (mode & SILC_CHANNEL_MODE_PRIVKEY)
+    strncat(string, "k", 1);
+
+  if (mode & SILC_CHANNEL_MODE_INVITE)
+    strncat(string, "i", 1);
+
+  if (mode & SILC_CHANNEL_MODE_TOPIC)
+    strncat(string, "t", 1);
+
+  if (mode & SILC_CHANNEL_MODE_ULIMIT)
+    strncat(string, "l", 1);
+
+  if (mode & SILC_CHANNEL_MODE_PASSPHRASE)
+    strncat(string, "a", 1);
+
+  if (mode & SILC_CHANNEL_MODE_FOUNDER_AUTH)
+    strncat(string, "f", 1);
+
+  if (mode & SILC_CHANNEL_MODE_CHANNEL_AUTH)
+    strncat(string, "C", 1);
+
+  if (mode & SILC_CHANNEL_MODE_SILENCE_USERS)
+    strncat(string, "m", 1);
+
+  if (mode & SILC_CHANNEL_MODE_SILENCE_OPERS)
+    strncat(string, "M", 1);
+
+  if (mode & SILC_CHANNEL_MODE_CIPHER)
+    strncat(string, "c", 1);
+
+  if (mode & SILC_CHANNEL_MODE_HMAC)
+    strncat(string, "h", 1);
+
+  if (mode & SILC_CHANNEL_MODE_CIPHER) {
+    if (strlen(cipher) + strlen(string) + 1< sizeof(string)) {
+      strncat(string, " ", 1);
+      strncat(string, cipher, strlen(cipher));
+    }
+  }
+
+  if (mode & SILC_CHANNEL_MODE_HMAC) {
+    if (strlen(hmac) + strlen(string) + 1< sizeof(string)) {
+      strncat(string, " ", 1);
+      strncat(string, hmac, strlen(hmac));
+    }
+  }
+
+  /* Rest of mode is ignored */
+
+  return strdup(string);
+}
+
+/* Parses channel user mode mask and returns te mode as string */
+
+char *silc_client_chumode(SilcUInt32 mode)
+{
+  char string[64];
+
+  if (!mode)
+    return NULL;
+
+  memset(string, 0, sizeof(string));
+
+  if (mode & SILC_CHANNEL_UMODE_CHANFO)
+    strncat(string, "f", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_CHANOP)
+    strncat(string, "o", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES)
+    strncat(string, "b", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_USERS)
+    strncat(string, "u", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_BLOCK_MESSAGES_ROBOTS)
+    strncat(string, "r", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_QUIET)
+    strncat(string, "q", 1);
+
+  return strdup(string);
+}
+
+/* Parses channel user mode and returns it as special mode character. */
+
+char *silc_client_chumode_char(SilcUInt32 mode)
+{
+  char string[64];
+
+  if (!mode)
+    return NULL;
+
+  memset(string, 0, sizeof(string));
+
+  if (mode & SILC_CHANNEL_UMODE_CHANFO)
+    strncat(string, "*", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_CHANOP)
+    strncat(string, "@", 1);
+
+  if (mode & SILC_CHANNEL_UMODE_QUIET)
+    strncat(string, "&", 1);
+
+  return strdup(string);
+}
+
+/* Renders ID to suitable to print for example to log file. */
+
+static char rid[256];
+#define _PUT_STRING(__d__, __s__)					\
+do {									\
+  int __sp = sizeof(__d__) - 1 - strlen(__d__);				\
+  if (__sp < strlen(__s__)) {						\
+    if (__sp)								\
+      strncat(__d__, __s__, (sizeof(__d__) - 1) - strlen(__d__));	\
+  } else {								\
+    strncat(__d__, __s__, strlen(__s__));				\
+  }									\
+} while(0)
+
+char *silc_id_render(void *id, SilcIdType id_type)
+{
+  char tmp[100];
+  unsigned char tmps[2];
+  char *cp;
+
+  memset(rid, 0, sizeof(rid));
+  switch(id_type) {
+  case SILC_ID_SERVER:
+    {
+      SilcServerID *server_id = (SilcServerID *)id;
+      if (server_id->ip.data_len > 4) {
+#ifdef HAVE_IPV6
+	struct sockaddr_in6 ipv6;
+	memset(&ipv6, 0, sizeof(ipv6));
+	ipv6.sin6_family = AF_INET6;
+	memmove(&ipv6.sin6_addr, server_id->ip.data, sizeof(ipv6.sin6_addr));
+	if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
+			 tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
+	  _PUT_STRING(rid, tmp);
+#endif
+      } else {
+	struct in_addr ipv4;
+	memmove(&ipv4.s_addr, server_id->ip.data, 4);
+	cp = inet_ntoa(ipv4);
+	if (cp)
+	  _PUT_STRING(rid, cp);
+      }
+
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(server_id->port));
+      _PUT_STRING(rid, tmp);
+      SILC_PUT16_MSB(server_id->rnd, tmps);
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+      _PUT_STRING(rid, tmp);
+    }
+    break;
+  case SILC_ID_CLIENT:
+    {
+      SilcClientID *client_id = (SilcClientID *)id;
+      if (client_id->ip.data_len > 4) {
+#ifdef HAVE_IPV6
+	struct sockaddr_in6 ipv6;
+	memset(&ipv6, 0, sizeof(ipv6));
+	ipv6.sin6_family = AF_INET6;
+	memmove(&ipv6.sin6_addr, client_id->ip.data, sizeof(ipv6.sin6_addr));
+	if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
+			 tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
+	  _PUT_STRING(rid, tmp);
+#endif
+      } else {
+	struct in_addr ipv4;
+	memmove(&ipv4.s_addr, client_id->ip.data, 4);
+	cp = inet_ntoa(ipv4);
+	if (cp)
+	  _PUT_STRING(rid, cp);
+      }
+
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, ",%02x,", client_id->rnd);
+      _PUT_STRING(rid, tmp);
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x %02x %02x...]",
+	       client_id->hash[0], client_id->hash[1],
+	       client_id->hash[2], client_id->hash[3]);
+      _PUT_STRING(rid, tmp);
+    }
+    break;
+  case SILC_ID_CHANNEL:
+    {
+      SilcChannelID *channel_id = (SilcChannelID *)id;
+      if (channel_id->ip.data_len > 4) {
+#ifdef HAVE_IPV6
+	struct sockaddr_in6 ipv6;
+	memset(&ipv6, 0, sizeof(ipv6));
+	ipv6.sin6_family = AF_INET6;
+	memmove(&ipv6.sin6_addr, channel_id->ip.data, sizeof(ipv6.sin6_addr));
+	if (!getnameinfo((struct sockaddr *)&ipv6, sizeof(ipv6),
+			 tmp, sizeof(tmp) - 1, NULL, 0, NI_NUMERICHOST))
+	  _PUT_STRING(rid, tmp);
+#endif
+      } else {
+	struct in_addr ipv4;
+	memmove(&ipv4.s_addr, channel_id->ip.data, 4);
+	cp = inet_ntoa(ipv4);
+	if (cp)
+	  _PUT_STRING(rid, cp);
+      }
+
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, ",%d,", ntohs(channel_id->port));
+      _PUT_STRING(rid, tmp);
+      SILC_PUT16_MSB(channel_id->rnd, tmps);
+      memset(tmp, 0, sizeof(tmp));
+      silc_snprintf(tmp, sizeof(tmp) - 1, "[%02x %02x]", tmps[0], tmps[1]);
+      _PUT_STRING(rid, tmp);
+    }
+    break;
+  }
+
+  return rid;
+}
+#undef _PUT_STRING