1 files changed, 674 insertions, 0 deletions

diff --git a/src/chat/gnunet-chat.c b/src/chat/gnunet-chat.c
new file mode 100644
index 000000000..b960db043
--- /dev/null
+++ b/src/chat/gnunet-chat.c
@@ -0,0 +1,674 @@
+/*
+     This file is part of GNUnet.
+     (C) 2007, 2008, 2011 Christian Grothoff (and other contributing authors)
+
+     GNUnet is free software; you can redistribute it and/or modify
+     it under the terms of the GNU General Public License as published
+     by the Free Software Foundation; either version 3, or (at your
+     option) any later version.
+
+     GNUnet is distributed in the hope that it will be useful, but
+     WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     General Public License for more details.
+
+     You should have received a copy of the GNU General Public License
+     along with GNUnet; see the file COPYING.  If not, write to the
+     Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+     Boston, MA 02111-1307, USA.
+*/
+
+/**
+ * @file chat/gnunet-chat.c
+ * @brief Minimal chat command line tool
+ * @author Christian Grothoff
+ * @author Nathan Evans
+ * @author Vitaly Minko
+ */
+
+#include "platform.h"
+#include "gnunet_getopt_lib.h"
+#include "gnunet_program_lib.h"
+#include "gnunet_chat_service.h"
+#include <fcntl.h>
+
+static int ret;
+
+static const struct GNUNET_CONFIGURATION_Handle *cfg;
+
+static char *nickname;
+
+static char *room_name;
+
+static struct GNUNET_CONTAINER_MetaData *meta;
+
+static struct GNUNET_CHAT_Room *room;
+
+static GNUNET_SCHEDULER_TaskIdentifier handle_cmd_task = GNUNET_SCHEDULER_NO_TASK;
+
+struct ChatCommand
+{
+  const char *command;
+  int (*Action) (const char *arguments, const void *xtra);
+  const char *helptext;
+};
+
+struct UserList
+{
+  struct UserList *next;
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded pkey;
+  int ignored;
+};
+
+static struct UserList *users;
+
+static void
+free_user_list ()
+{
+  struct UserList *next;
+  while (NULL != users)
+    {
+      next = users->next;
+      GNUNET_free (users);
+      users = next;
+    }
+}
+
+static int do_help (const char *args, const void *xtra);
+
+
+/**
+ * Callback used for notification about incoming messages.
+ *
+ * @param cls closure, NULL
+ * @param room in which room was the message received?
+ * @param sender what is the ID of the sender? (maybe NULL)
+ * @param member_info information about the joining member
+ * @param message the message text
+ * @param options options for the message
+ * @return GNUNET_OK to accept the message now, GNUNET_NO to
+ *         accept (but user is away), GNUNET_SYSERR to signal denied delivery
+ */
+static int
+receive_cb (void *cls,
+            struct GNUNET_CHAT_Room *room,
+            const GNUNET_HashCode *sender,
+            const struct GNUNET_CONTAINER_MetaData *meta,
+            const char *message,
+            enum GNUNET_CHAT_MsgOptions options)
+{
+  char *nick;
+  const char *fmt;
+
+  if (NULL != sender)
+    nick = GNUNET_PSEUDONYM_id_to_name (cfg, sender);
+  else
+    nick = GNUNET_strdup (_("anonymous"));
+  fmt = NULL;
+  switch (options)
+    {
+    case GNUNET_CHAT_MSG_OPTION_NONE:
+    case GNUNET_CHAT_MSG_ANONYMOUS:
+      fmt = _("`%s' said: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_PRIVATE:
+      fmt = _("`%s' said to you: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_PRIVATE | GNUNET_CHAT_MSG_ANONYMOUS:
+      fmt = _("`%s' said to you: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_AUTHENTICATED:
+      fmt = _("`%s' said for sure: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_PRIVATE | GNUNET_CHAT_MSG_AUTHENTICATED:
+      fmt = _("`%s' said to you for sure: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_ACKNOWLEDGED:
+      fmt = _("`%s' was confirmed that you received: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_PRIVATE | GNUNET_CHAT_MSG_ACKNOWLEDGED:
+      fmt = _("`%s' was confirmed that you and only you received: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_AUTHENTICATED | GNUNET_CHAT_MSG_ACKNOWLEDGED:
+      fmt = _("`%s' was confirmed that you received from him or her: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_AUTHENTICATED | GNUNET_CHAT_MSG_PRIVATE | GNUNET_CHAT_MSG_ACKNOWLEDGED:
+      fmt =
+        _
+        ("`%s' was confirmed that you and only you received from him or her: %s\n");
+      break;
+    case GNUNET_CHAT_MSG_OFF_THE_RECORD:
+      fmt = _("`%s' said off the record: %s\n");
+      break;
+    default:
+      fmt = _("<%s> said using an unknown message type: %s\n");
+      break;
+    }
+  fprintf (stdout, fmt, nick, message);
+  GNUNET_free (nick);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Callback used for message delivery confirmations.
+ *
+ * @param cls closure, NULL
+ * @param room in which room was the message received?
+ * @param orig_seq_number sequence number of the original message
+ * @param timestamp when was the message received?
+ * @param receiver who is confirming the receipt?
+ * @param msg_hash hash of the original message
+ * @param receipt signature confirming delivery
+ * @return GNUNET_OK to continue, GNUNET_SYSERR to refuse processing further
+ *         confirmations from anyone for this message
+ */
+static int
+confirmation_cb (void *cls,
+                 struct GNUNET_CHAT_Room *room,
+                 uint32_t orig_seq_number,
+                 struct GNUNET_TIME_Absolute timestamp,
+                 const GNUNET_HashCode *receiver,
+                 const GNUNET_HashCode *msg_hash,
+                 const struct GNUNET_CRYPTO_RsaSignature *receipt)
+{
+  char *nick;
+
+  nick = GNUNET_PSEUDONYM_id_to_name (cfg, receiver);
+  fprintf (stdout, _("'%s' acknowledged message #%d\n"), nick, orig_seq_number);
+  return GNUNET_OK;
+}
+
+
+/**
+ * Callback used for notification that another room member has joined or left.
+ *
+ * @param member_info will be non-null if the member is joining, NULL if he is
+ *        leaving
+ * @param member_id hash of public key of the user (for unique identification)
+ * @param options what types of messages is this member willing to receive?
+ * @return GNUNET_OK
+ */
+static int
+member_list_cb (void *cls,
+                const struct GNUNET_CONTAINER_MetaData *member_info,
+                const struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded *member_id,
+                enum GNUNET_CHAT_MsgOptions options)
+{
+  char *nick;
+  GNUNET_HashCode id;
+  struct UserList *pos;
+  struct UserList *prev;
+
+  GNUNET_CRYPTO_hash (member_id,
+                      sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                      &id);
+  nick = GNUNET_PSEUDONYM_id_to_name (cfg, &id);
+  fprintf (stdout, member_info != NULL
+           ? _("`%s' entered the room\n") : _("`%s' left the room\n"), nick);
+  GNUNET_free (nick);
+  if (NULL != member_info)
+    {
+      /* user joining */
+      pos = GNUNET_malloc (sizeof (struct UserList));
+      pos->next = users;
+      pos->pkey = *member_id;
+      pos->ignored = GNUNET_NO;
+      users = pos;
+    }
+  else
+    {
+      /* user leaving */
+      prev = NULL;
+      pos = users;
+      while ((NULL != pos) &&
+             (0 != memcmp (&pos->pkey,
+                           member_id,
+                           sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded))))
+        {
+          prev = pos;
+          pos = pos->next;
+        }
+      if (NULL == pos)
+        {
+          GNUNET_break (0);
+        }
+      else
+        {
+          if (NULL == prev)
+            users = pos->next;
+          else
+            prev->next = pos->next;
+          GNUNET_free (pos);
+        }
+    }
+  return GNUNET_OK;
+}
+
+
+static int
+do_transmit (const char *msg, const void *xtra)
+{
+  uint32_t seq;
+  GNUNET_CHAT_send_message (room,
+                            msg,
+                            GNUNET_CHAT_MSG_OPTION_NONE,
+                            NULL, &seq);
+  return GNUNET_OK;
+}
+
+
+static int
+do_join (const char *arg, const void *xtra)
+{
+  char *my_name;
+  GNUNET_HashCode me;
+
+  if (arg[0] == '#')
+    arg++;                      /* ignore first hash */
+  GNUNET_CHAT_leave_room (room);
+  free_user_list ();
+  GNUNET_free (room_name);
+  room_name = GNUNET_strdup (arg);
+  room = GNUNET_CHAT_join_room (cfg,
+                                nickname,
+                                meta,
+                                room_name,
+                                -1,
+                                &receive_cb, NULL,
+                                &member_list_cb, NULL,
+                                &confirmation_cb, NULL, &me);
+  if (NULL == room)
+    {
+      fprintf (stdout, _("Could not change username\n"));
+      return GNUNET_SYSERR;
+    }
+  my_name = GNUNET_PSEUDONYM_id_to_name (cfg, &me);
+  fprintf (stdout, _("Joined room `%s' as user `%s'\n"), room_name, my_name);
+  GNUNET_free (my_name);
+  return GNUNET_OK;
+}
+
+
+static int
+do_nick (const char *msg, const void *xtra)
+{
+  char *my_name;
+  GNUNET_HashCode me;
+
+  GNUNET_CHAT_leave_room (room);
+  free_user_list ();
+  GNUNET_free (nickname);
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  nickname = GNUNET_strdup (msg);
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_insert (meta,
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_TITLE,
+                                     EXTRACTOR_METAFORMAT_UTF8,
+                                     "text/plain",
+                                     nickname,
+                                     strlen(nickname)+1);
+  room = GNUNET_CHAT_join_room (cfg,
+                                nickname,
+                                meta,
+                                room_name,
+                                -1,
+                                &receive_cb, NULL,
+                                &member_list_cb, NULL,
+                                &confirmation_cb, NULL, &me);
+  if (NULL == room)
+    {
+      fprintf (stdout, _("Could not change username\n"));
+      return GNUNET_SYSERR;
+    }
+  my_name = GNUNET_PSEUDONYM_id_to_name (cfg, &me);
+  fprintf (stdout, _("Changed username to `%s'\n"), my_name);
+  GNUNET_free (my_name);
+  return GNUNET_OK;
+}
+
+
+static int
+do_names (const char *msg, const void *xtra)
+{
+  char *name;
+  struct UserList *pos;
+  GNUNET_HashCode pid;
+
+  fprintf (stdout, _("Users in room `%s': "), room_name);
+  pos = users;
+  while (NULL != pos)
+    {
+      GNUNET_CRYPTO_hash (&pos->pkey,
+                          sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                          &pid);
+      name = GNUNET_PSEUDONYM_id_to_name (cfg, &pid);
+      fprintf (stdout, "`%s' ", name);
+      GNUNET_free (name);
+      pos = pos->next;
+    }
+  fprintf (stdout, "\n");
+  return GNUNET_OK;
+}
+
+
+static int
+do_pm (const char *msg, const void *xtra)
+{
+  char *user;
+  GNUNET_HashCode uid;
+  GNUNET_HashCode pid;
+  uint32_t seq;
+  struct UserList *pos;
+
+  if (NULL == strstr (msg, " "))
+    {
+      fprintf (stderr, _("Syntax: /msg USERNAME MESSAGE"));
+      return GNUNET_OK;
+    }
+  user = GNUNET_strdup (msg);
+  strstr (user, " ")[0] = '\0';
+  msg += strlen (user) + 1;
+  if (GNUNET_OK != GNUNET_PSEUDONYM_name_to_id (cfg, user, &uid))
+    {
+      fprintf (stderr, _("Unknown user `%s'\n"), user);
+      GNUNET_free (user);
+      return GNUNET_OK;
+    }
+  pos = users;
+  while (NULL != pos)
+    {
+      GNUNET_CRYPTO_hash (&pos->pkey,
+                          sizeof (struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded),
+                          &pid);
+      if (0 == memcmp (&pid, &uid, sizeof (GNUNET_HashCode)))
+        break;
+      pos = pos->next;
+    }
+  if (NULL == pos)
+    {
+      fprintf (stderr, _("User `%s' is currently not in the room!\n"), user);
+      GNUNET_free (user);
+      return GNUNET_OK;
+    }
+  GNUNET_CHAT_send_message (room,
+                            msg,
+                            GNUNET_CHAT_MSG_PRIVATE,
+                            &pos->pkey,
+                            &seq);
+  GNUNET_free (user);
+  return GNUNET_OK;
+}
+
+
+static int
+do_transmit_sig (const char *msg, const void *xtra)
+{
+  uint32_t seq;
+  GNUNET_CHAT_send_message (room,
+                            msg,
+                            GNUNET_CHAT_MSG_AUTHENTICATED,
+                            NULL, &seq);
+  return GNUNET_OK;
+}
+
+
+static int
+do_transmit_ack (const char *msg, const void *xtra)
+{
+  uint32_t seq;
+  GNUNET_CHAT_send_message (room,
+                            msg,
+                            GNUNET_CHAT_MSG_ACKNOWLEDGED,
+                            NULL, &seq);
+  return GNUNET_OK;
+}
+
+
+static int
+do_quit (const char *args, const void *xtra)
+{
+  return GNUNET_SYSERR;
+}
+
+
+static int
+do_unknown (const char *msg, const void *xtra)
+{
+  fprintf (stderr, _("Unknown command `%s'\n"), msg);
+  return GNUNET_OK;
+}
+
+
+/**
+ * List of supported IRC commands. The order matters!
+ */
+static struct ChatCommand commands[] = {
+  {"/join ", &do_join,
+   gettext_noop
+   ("Use `/join #roomname' to join a chat room. Joining a room will cause you"
+    " to leave the current room")},
+  {"/nick ", &do_nick,
+   gettext_noop
+   ("Use `/nick nickname' to change your nickname.  This will cause you to"
+    " leave the current room and immediately rejoin it with the new name.")},
+  {"/msg ", &do_pm,
+   gettext_noop
+   ("Use `/msg nickname message' to send a private message to the specified"
+    " user")},
+  {"/notice ", &do_pm,
+   gettext_noop ("The `/notice' command is an alias for `/msg'")},
+  {"/query ", &do_pm,
+   gettext_noop ("The `/query' command is an alias for `/msg'")},
+  {"/sig ", &do_transmit_sig,
+   gettext_noop ("Use `/sig message' to send a signed public message")},
+  {"/ack ", &do_transmit_ack,
+   gettext_noop
+   ("Use `/ack message' to require signed acknowledgment of the message")},
+  {"/quit", &do_quit,
+   gettext_noop ("Use `/quit' to terminate gnunet-chat")},
+  {"/leave", &do_quit,
+   gettext_noop ("The `/leave' command is an alias for `/quit'")},
+  {"/names", &do_names,
+   gettext_noop
+   ("Use `/names' to list all of the current members in the chat room")},
+  {"/help", &do_help,
+   gettext_noop ("Use `/help command' to get help for a specific command")},
+  /* Add standard commands:
+     /whois (print metadata),
+     /ignore (set flag, check on receive!) */
+  /* Add special commands (currently supported):
+     + anonymous msgs
+     + authenticated msgs
+   */
+  /* the following three commands must be last! */
+  {"/", &do_unknown, NULL},
+  {"", &do_transmit, NULL},
+  {NULL, NULL, NULL},
+};
+
+
+static int
+do_help (const char *args, const void *xtra)
+{
+  int i;
+  i = 0;
+  while ((NULL != args) &&
+         (0 != strlen (args)) && (commands[i].Action != &do_help))
+    {
+      if (0 ==
+          strncasecmp (&args[1], &commands[i].command[1], strlen (args) - 1))
+        {
+          fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+          return GNUNET_OK;
+        }
+      i++;
+    }
+  i = 0;
+  fprintf (stdout, "Available commands:");
+  while (commands[i].Action != &do_help)
+    {
+      fprintf (stdout, " %s", gettext (commands[i].command));
+      i++;
+    }
+  fprintf (stdout, "\n");
+  fprintf (stdout, "%s\n", gettext (commands[i].helptext));
+  return GNUNET_OK;
+}
+
+
+static void 
+do_stop_task (void *cls,
+              const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  GNUNET_CHAT_leave_room (room);
+  if (handle_cmd_task != GNUNET_SCHEDULER_NO_TASK)
+    {
+      GNUNET_SCHEDULER_cancel (handle_cmd_task);
+      handle_cmd_task = GNUNET_SCHEDULER_NO_TASK;
+    }     
+  free_user_list ();
+  GNUNET_CONTAINER_meta_data_destroy (meta);
+  GNUNET_free (room_name);
+  GNUNET_free (nickname);
+}
+
+
+void
+handle_command (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
+{
+  char message[MAX_MESSAGE_LENGTH + 1];
+  int i;
+
+  /* read message from command line and handle it */
+  memset (message, 0, MAX_MESSAGE_LENGTH + 1);
+  if (NULL == fgets (message, MAX_MESSAGE_LENGTH, stdin))
+    goto next;
+  if (strlen (message) == 0)
+    goto next;
+  if (message[strlen (message) - 1] == '\n')
+    message[strlen (message) - 1] = '\0';
+  if (strlen (message) == 0)
+    goto next;
+  i = 0;
+  while ((NULL != commands[i].command) &&
+         (0 != strncasecmp (commands[i].command,
+                            message, strlen (commands[i].command))))
+    i++;
+  if (GNUNET_OK !=
+      commands[i].Action (&message[strlen (commands[i].command)], NULL))
+    goto out;
+
+next:
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MILLISECONDS,
+                                                                 100),
+                                  &handle_command,
+                                  NULL);
+  return;
+
+out:
+  handle_cmd_task = GNUNET_SCHEDULER_NO_TASK;
+  GNUNET_SCHEDULER_shutdown ();
+}
+
+
+/**
+ * Main function that will be run by the scheduler.
+ *
+ * @param cls closure, NULL
+ * @param args remaining command-line arguments
+ * @param cfgfile name of the configuration file used (for saving, can be NULL!)
+ * @param cfg configuration
+ */
+static void
+run (void *cls,
+     char *const *args,
+     const char *cfgfile,
+     const struct GNUNET_CONFIGURATION_Handle *c)
+{
+  GNUNET_HashCode me;
+  char *my_name;
+
+  cfg = c;
+  /* check arguments */
+  if (NULL == nickname)
+    {
+      fprintf (stderr, _("You must specify a nickname\n"));
+      ret = -1;
+      return;
+    }
+  if (NULL == room_name)
+    room_name = GNUNET_strdup ("gnunet");
+  meta = GNUNET_CONTAINER_meta_data_create ();
+  GNUNET_CONTAINER_meta_data_insert (meta,
+                                     "<gnunet>",
+                                     EXTRACTOR_METATYPE_TITLE,
+                                     EXTRACTOR_METAFORMAT_UTF8,
+                                     "text/plain",
+                                     nickname,
+                                     strlen(nickname)+1);
+  room = GNUNET_CHAT_join_room (cfg,
+                                nickname,
+                                meta,
+                                room_name,
+                                -1,
+                                &receive_cb, NULL,
+                                &member_list_cb, NULL,
+                                &confirmation_cb, NULL, &me);
+  if (NULL == room)
+    {
+      fprintf (stderr, _("Failed to join room `%s'\n"), room_name);
+      GNUNET_free (room_name);
+      GNUNET_free (nickname);
+      GNUNET_CONTAINER_meta_data_destroy (meta);
+      ret = -1;
+      return;
+    }
+  my_name = GNUNET_PSEUDONYM_id_to_name (cfg, &me);
+  fprintf (stdout, _("Joined room `%s' as user `%s'\n"), room_name, my_name);
+  GNUNET_free (my_name);
+  handle_cmd_task =
+    GNUNET_SCHEDULER_add_with_priority (GNUNET_SCHEDULER_PRIORITY_UI,
+                                        &handle_command,
+                                        NULL);
+  GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_UNIT_FOREVER_REL,
+                                &do_stop_task,
+                                NULL);
+}
+
+
+/**
+ * The main function to chat via GNUnet.
+ *
+ * @param argc number of arguments from the command line
+ * @param argv command line arguments
+ * @return 0 ok, 1 on error
+ */
+int
+main (int argc, char *const *argv)
+{
+  int flags;
+  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
+    {'n', "nick", "NAME",
+     gettext_noop ("set the nickname to use (required)"),
+     1, &GNUNET_GETOPT_set_string, &nickname},
+    {'r', "room", "NAME",
+     gettext_noop ("set the chat room to join"),
+     1, &GNUNET_GETOPT_set_string, &room_name},
+    GNUNET_GETOPT_OPTION_END
+  };
+
+  flags = fcntl (0, F_GETFL, 0);
+  flags |= O_NONBLOCK;
+  fcntl (0, F_SETFL, flags);
+  return (GNUNET_OK ==
+          GNUNET_PROGRAM_run (argc,
+                              argv,
+                              "gnunet-chat",
+                              gettext_noop ("Join a chat on GNUnet."),
+                              options, &run, NULL)) ? ret : 1;
+}
+
+/* end of gnunet-chat.c */