[GNUnet-SVN] r8829 - in gnunet/src: core fs include

[gnunet]

Author: grothoff
Date: 2009-08-16 03:31:25 -0600 (Sun, 16 Aug 2009)
New Revision: 8829

Modified:
   gnunet/src/core/gnunet-service-core.c
   gnunet/src/fs/Makefile.am
   gnunet/src/fs/fs.h
   gnunet/src/fs/fs_uri.c
   gnunet/src/include/gnunet_container_lib.h
   gnunet/src/include/gnunet_fs_service.h
Log:
move-hacknig

Modified: gnunet/src/core/gnunet-service-core.c
===================================================================
--- gnunet/src/core/gnunet-service-core.c       2009-08-15 22:14:18 UTC (rev 
8828)
+++ gnunet/src/core/gnunet-service-core.c       2009-08-16 09:31:25 UTC (rev 
8829)
@@ -2353,7 +2353,7 @@
     }
 #if DEBUG_CORE
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Decrypting key material.\n");
-#endif
+#endif  
   if ((GNUNET_CRYPTO_rsa_decrypt (my_private_key,
                                   &m->encrypted_key,
                                   &k,

Modified: gnunet/src/fs/Makefile.am
===================================================================
--- gnunet/src/fs/Makefile.am   2009-08-15 22:14:18 UTC (rev 8828)
+++ gnunet/src/fs/Makefile.am   2009-08-16 09:31:25 UTC (rev 8829)
@@ -13,11 +13,15 @@
 lib_LTLIBRARIES = libgnunetfs.la
 
 libgnunetfs_la_SOURCES = \
+  fs_collection.c \
+  fs_directory.c \
   fs_getopt.c \
   fs_uri.c 
+
 libgnunetfs_la_LIBADD = \
   $(top_builddir)/src/util/libgnunetutil.la \
   $(GN_LIBINTL) $(XLIB)
+
 libgnunetfs_la_LDFLAGS = \
   $(GN_LIB_LDFLAGS)  $(WINFLAGS) \
   -version-info 0:0:0

Modified: gnunet/src/fs/fs.h
===================================================================
--- gnunet/src/fs/fs.h  2009-08-15 22:14:18 UTC (rev 8828)
+++ gnunet/src/fs/fs.h  2009-08-16 09:31:25 UTC (rev 8829)
@@ -27,6 +27,11 @@
 #define FS_H
 
 /**
+ * Size of the individual blocks used for file-sharing.
+ */
+#define GNUNET_FS_DBLOCK_SIZE (32*1024)
+
+/**
  * @brief content hash key
  */
 struct ContentHashKey 

Modified: gnunet/src/fs/fs_uri.c
===================================================================
--- gnunet/src/fs/fs_uri.c      2009-08-15 22:14:18 UTC (rev 8828)
+++ gnunet/src/fs/fs_uri.c      2009-08-16 09:31:25 UTC (rev 8829)
@@ -182,8 +182,6 @@
 }
 
 
-
-
 /**
  * Given a keyword with %-encoding (and possibly quotes to protect
  * spaces), return a copy of the keyword without %-encoding and
@@ -762,10 +760,130 @@
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_loc_create (const struct GNUNET_FS_Uri *baseUri,
                          struct GNUNET_CONFIGURATION_Handle *cfg,
-                         struct GNUNET_TIME_Absolute expiration_time);
+                         struct GNUNET_TIME_Absolute expiration_time)
+{
+  struct GNUNET_FS_Uri *uri;
+  struct GNUNET_CRYPTO_RsaPrivateKey *my_private_key;  
+  struct GNUNET_CRYPTO_RsaPublicKeyBinaryEncoded my_public_key;
+  char *keyfile;
+  struct LocUriAssembly ass;
 
+  if (baseUri->type != chk)
+    return NULL;
+  if (GNUNET_OK !=
+      GNUNET_CONFIGURATION_get_value_filename (cfg,
+                                              "GNUNETD",
+                                              "HOSTKEY", &keyfile))
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _
+                  ("Lacking key configuration settings.\n"));
+      return NULL;
+    }
+  my_private_key = GNUNET_CRYPTO_rsa_key_create_from_file (keyfile);
+  if (my_private_key == NULL)
+    {
+      GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
+                  _("Could not access hostkey file `%s'.\n"),
+                 keyfile);
+      GNUNET_free (keyfile);
+      return NULL;
+    }
+  GNUNET_free (keyfile);
+  GNUNET_CRYPTO_rsa_key_get_public (my_private_key, &my_public_key);
+  ass.purpose.size = htonl(sizeof(struct LocUriAssembly));
+  ass.purpose.purpose = htonl(GNUNET_SIGNATURE_PURPOSE_NAMESPACE_PLACEMENT);
+  ass.exptime = GNUNET_TIME_absolute_hton (expiration_time);
+  ass.fi = baseUri->data.chk;
+  ass.peer = my_public_key;
+  uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
+  uri->type = loc;
+  uri->data.loc.fi = baseUri->data.chk;
+  uri->data.loc.expirationTime = expiration_time;
+  uri->data.loc.peer = my_public_key;
+  GNUNET_assert (GNUNET_OK ==
+                GNUNET_CRYPTO_rsa_sign (my_private_key,
+                                        &ass.purpose,
+                                        &uri->data.loc.contentSignature));
+  GNUNET_CRYPTO_rsa_key_free (my_private_key);
+  return uri;
+}
 
+
 /**
+ * Canonicalize a keyword.
+ * 
+ * @param in input string (the keyword)
+ * @return canonicalized keyword
+ */
+static char *
+canonicalize_keyword (const char *in)
+{
+  char *ret;
+  char *wpos;
+  const char *rpos;
+
+  ret = GNUNET_strdup (in);
+  wpos = ret;
+  rpos = in;
+  while ('\0' != *rpos)
+    {
+      switch (tolower(*rpos))
+       {
+       case 'a':
+       case 'e':
+       case 'i':
+       case 'o':
+       case 'u':
+       case ' ':
+       case '\t':
+       case '\n':
+       case '\r':
+         /* skip characters listed above */
+         rpos++;
+         break;
+       case 'b':
+       case 'c':
+       case 'd':
+       case 'f':
+       case 'g':
+       case 'h':
+       case 'j':
+       case 'k':
+       case 'l':
+       case 'm':
+       case 'n':
+       case 'p':
+       case 'r':
+       case 's':
+       case 't':
+       case 'v':
+       case 'w':
+       case 'x':
+       case 'y':
+       case 'z':
+         /* convert characters listed above to lower case */
+         *wpos = tolower(*rpos);
+         wpos++;
+       case '!':
+       case '.':
+       case '?':
+       case '-':
+         /* keep characters listed above without changes */
+         *wpos = *rpos;
+         wpos++;
+       default:
+         /* replace characters listed above with '_' */
+         *wpos = '_';
+         wpos++;
+       }
+      rpos++;
+    }
+  return ret;
+}
+
+
+/**
  * Canonicalize keyword URI.  Performs operations such
  * as decapitalization and removal of certain characters.
  * (useful for search).
@@ -776,8 +894,20 @@
 struct GNUNET_FS_Uri *
 GNUNET_FS_uri_ksk_canonicalize (const struct GNUNET_FS_Uri *uri)
 {
-  /* FIXME: not implemented */
-  return NULL;
+  struct GNUNET_FS_Uri *ret;
+  unsigned int kc;
+  unsigned int i;
+  char **kl;
+
+  kc = uri->data.ksk.keywordCount;
+  kl = GNUNET_malloc (kc*sizeof(char*));
+  for (i=0;i<kc;i++)
+    kl[i] = canonicalize_keyword (uri->data.ksk.keywords[i]);
+  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  ret->type = ksk;
+  ret->data.ksk.keywordCount = kc;
+  ret->data.ksk.keywords = kl;
+  return ret;
 }
 
 
@@ -794,8 +924,45 @@
 GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
                         const struct GNUNET_FS_Uri *u2)
 {
-  /* FIXME */
-  return NULL;
+  struct GNUNET_FS_Uri *ret;
+  unsigned int kc;
+  unsigned int i;
+  unsigned int j;
+  int found;
+  const char *kp;
+  char **kl;
+
+  if ( (u1->type != ksk) ||
+       (u2->type != ksk) )
+    {
+      GNUNET_break (0);
+      return NULL;
+    } 
+  kc = u1->data.ksk.keywordCount;
+  kl = GNUNET_malloc ((kc+u2->data.ksk.keywordCount)*sizeof(char*));
+  for (i=0;i<u1->data.ksk.keywordCount;i++)
+    kl[i] = GNUNET_strdup (u1->data.ksk.keywords[i]);
+  for (i=0;i<u2->data.ksk.keywordCount;i++)
+    {
+      kp = u2->data.ksk.keywords[i];
+      found = 0;
+      for (j=0;j<u1->data.ksk.keywordCount;j++)
+       if (0 == strcmp(kp + 1,
+                       kl[j]+1))
+         {
+           found = 1;
+           if (kp[0] == '+')
+             kl[j][0] = '+';
+           break;
+         }
+      if (0 == found)
+       kl[kc++] = GNUNET_strdup (kp - 1);
+    }
+  ret = GNUNET_malloc (sizeof(struct GNUNET_FS_Uri));
+  ret->type = ksk;
+  ret->data.ksk.keywordCount = kc;
+  ret->data.ksk.keywords = kl;
+  return ret;
 }
 
 
@@ -852,14 +1019,86 @@
  * "OR"ed keywords 'foo' and 'bar', not into '"foo bar"'.
  *
  * @param keywords the keyword string
+ * @param emsg where to store an error message
  * @return an FS URI for the given keywords, NULL
  *  if keywords is not legal (i.e. empty).
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create (const char *keywords)
+GNUNET_FS_uri_ksk_create (const char *keywords,
+                         char **emsg)
 {
-  /* FIXME */
-  return NULL;
+  char **keywordarr;
+  unsigned int num_Words;
+  int inWord;
+  char *pos;
+  struct GNUNET_FS_Uri *uri;
+  char *searchString;
+  int saw_quote;
+
+  if (keywords == NULL)
+    {
+      GNUNET_break (0);
+      return NULL;
+    }
+  searchString = GNUNET_strdup (keywords);
+  num_Words = 0;
+  inWord = 0;
+  saw_quote = 0;
+  pos = searchString;
+  while ('\0' != *pos)
+    {
+      if ((saw_quote == 0) && (isspace (*pos)))
+        {
+          inWord = 0;
+        }
+      else if (0 == inWord)
+        {
+          inWord = 1;
+          ++num_Words;
+        }
+      if ('"' == *pos)
+        saw_quote = (saw_quote + 1) % 2;
+      pos++;
+    }
+  if (num_Words == 0)
+    {
+      GNUNET_free (searchString);
+      *emsg = GNUNET_strdup (_("No keywords specified!\n"));
+      return NULL;
+    }
+  if (saw_quote != 0)
+    {
+      GNUNET_free (searchString);
+      *emsg = GNUNET_strdup (_("Number of double-quotes not balanced!\n"));
+      return NULL;
+    }
+  keywordarr = GNUNET_malloc (num_Words * sizeof (char *));
+  num_Words = 0;
+  inWord = 0;
+  pos = searchString;
+  while ('\0' != *pos)
+    {
+      if ((saw_quote == 0) && (isspace (*pos)))
+        {
+          inWord = 0;
+          *pos = '\0';
+        }
+      else if (0 == inWord)
+        {
+          keywordarr[num_Words] = pos;
+          inWord = 1;
+          ++num_Words;
+        }
+      if ('"' == *pos)
+        saw_quote = (saw_quote + 1) % 2;
+      pos++;
+    }
+  uri =
+    GNUNET_FS_uri_ksk_create_from_args (num_Words,
+                                       (const char **) keywordarr);
+  GNUNET_free (keywordarr);
+  GNUNET_free (searchString);
+  return uri;
 }
 
 
@@ -884,8 +1123,49 @@
 GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
                                    const char **argv)
 {
-  /* FIXME */
-  return NULL;
+  unsigned int i;
+  struct GNUNET_FS_Uri *uri;
+  const char *keyword;
+  char *val;
+  const char *r;
+  char *w;
+  char *emsg;
+
+  if (argc == 0)
+    return NULL;
+  /* allow URI to be given as one and only keyword and
+     handle accordingly */
+  emsg = NULL;
+  if ( (argc == 1) &&
+       (strlen(argv[0]) > strlen(GNUNET_FS_URI_PREFIX)) &&
+       (strncmp(argv[0], GNUNET_FS_URI_PREFIX, strlen(GNUNET_FS_URI_PREFIX)) ) 
&&
+       (NULL != (uri = GNUNET_FS_uri_parse(argv[0], &emsg)) ) )
+    return uri;
+  GNUNET_free_non_null (emsg);
+  uri = GNUNET_malloc (sizeof (struct GNUNET_FS_Uri));
+  uri->type = ksk;
+  uri->data.ksk.keywordCount = argc;
+  uri->data.ksk.keywords = GNUNET_malloc (argc * sizeof (char *));
+  for (i = 0; i < argc; i++)
+    {
+      keyword = argv[i];
+      if (keyword[0] == '+')
+       val = GNUNET_strdup (keyword);
+      else
+        GNUNET_asprintf (&val, " %s", keyword);
+      r = val;
+      w = val;
+      while ('\0' != *r)
+        {
+          if ('"' == *r)
+            r++;
+          else
+            *(w++) = *(r++);
+        }
+      *w = '\0';
+      uri->data.ksk.keywords[i] = val;
+    }
+  return uri;
 }
 
 
@@ -1024,8 +1304,20 @@
 GNUNET_FS_uri_sks_to_string_fancy (struct GNUNET_CONFIGURATION_Handle *cfg,
                                   const struct GNUNET_FS_Uri *uri)
 {
-  /* FIXME */
-  return NULL;
+  char *ret;
+  char *name;
+
+  if (uri->type != sks)
+    return NULL;
+  name = GNUNET_PSEUDONYM_id_to_name (cfg, &uri->data.sks.namespace);
+  if (name == NULL)
+    return GNUNET_FS_uri_to_string (uri);
+  GNUNET_asprintf (&ret,
+                  "%s: %s",
+                  name,
+                  uri->data.sks.identifier);
+  GNUNET_free (name);
+  return ret;
 }
 
 
@@ -1299,6 +1591,8 @@
 /**
  * Convert binary data to a string.
  *
+ * @param data binary data to convert
+ * @param size number of bytes in data
  * @return converted data
  */
 static char *
@@ -1409,47 +1703,4 @@
     }
 }
 
-
-#if 0
-
-/**
- * Construct a location URI.
- *
- * @param baseURI content offered by the sender
- * @param sender identity of the peer with the content
- * @param expiration_time how long will the content be offered?
- * @param proto transport protocol to reach the peer
- * @param sas sender address size (for HELLO)
- * @param address sas bytes of address information
- * @param signer function to call for obtaining
- *        RSA signatures for "sender".
- * @return the location URI
- */
-struct GNUNET_ECRS_URI *
-GNUNET_ECRS_location_to_uri (const struct GNUNET_ECRS_URI *baseUri,
-                             const GNUNET_RSA_PublicKey * sender,
-                             GNUNET_Int32Time expirationTime,
-                             GNUNET_ECRS_SignFunction signer,
-                             void *signer_cls)
-{
-  struct GNUNET_ECRS_URI *uri;
-
-  if (baseUri->type != chk)
-    return NULL;
-
-  uri = GNUNET_malloc (sizeof (struct GNUNET_ECRS_URI));
-  uri->type = loc;
-  uri->data.loc.fi = baseUri->data.fi;
-  uri->data.loc.peer = *sender;
-  uri->data.loc.expirationTime = expirationTime;
-  signer (signer_cls,
-          sizeof (GNUNET_EC_FileIdentifier) +
-          sizeof (GNUNET_PeerIdentity) +
-          sizeof (GNUNET_Int32Time),
-          &uri->data.loc.fi, &uri->data.loc.contentSignature);
-  return uri;
-}
-
-#endif
-
-/* end of uri.c */
+/* end of fs_uri.c */

Modified: gnunet/src/include/gnunet_container_lib.h
===================================================================
--- gnunet/src/include/gnunet_container_lib.h   2009-08-15 22:14:18 UTC (rev 
8828)
+++ gnunet/src/include/gnunet_container_lib.h   2009-08-16 09:31:25 UTC (rev 
8829)
@@ -267,7 +267,7 @@
  *  otherwise client is responsible for freeing the value!
  */
 char *GNUNET_CONTAINER_meta_data_get_by_type (const struct
-                                              GNUNET_CONTAINER_MetaData *md,
+                                             GNUNET_CONTAINER_MetaData *md,
                                               EXTRACTOR_KeywordType type);
 
 /**

Modified: gnunet/src/include/gnunet_fs_service.h
===================================================================
--- gnunet/src/include/gnunet_fs_service.h      2009-08-15 22:14:18 UTC (rev 
8828)
+++ gnunet/src/include/gnunet_fs_service.h      2009-08-16 09:31:25 UTC (rev 
8829)
@@ -243,11 +243,13 @@
  * "OR"ed keywords 'foo' and 'bar', not into '"foo bar"'.
  *
  * @param keywords the keyword string
+ * @param emsg where to store an error message
  * @return an FS URI for the given keywords, NULL
  *  if keywords is not legal (i.e. empty).
  */
 struct GNUNET_FS_Uri *
-GNUNET_FS_uri_ksk_create (const char *keywords);
+GNUNET_FS_uri_ksk_create (const char *keywords,
+                         char **emsg);
 
 
 /**
@@ -2032,9 +2034,9 @@
 /* ******************** Directory API *********************** */
 
 
-#define GNUNET_DIRECTORY_MIME  "application/gnunet-directory"
-#define GNUNET_DIRECTORY_MAGIC "\211GND\r\n\032\n"
-#define GNUNET_DIRECTORY_EXT   ".gnd"
+#define GNUNET_FS_DIRECTORY_MIME  "application/gnunet-directory"
+#define GNUNET_FS_DIRECTORY_MAGIC "\211GND\r\n\032\n"
+#define GNUNET_FS_DIRECTORY_EXT   ".gnd"
 
 /**
  * Does the meta-data claim that this is a directory?
@@ -2063,7 +2065,8 @@
  * @param cls closure
  * @param filename name of the file in the directory
  * @param uri URI of the file
- * @param metadata metadata for the file
+ * @param metadata metadata for the file; metadata for
+ *        the directory if everything else is NULL/zero
  * @param length length of the available data for the file
  *           (of type size_t since data must certainly fit
  *            into memory; if files are larger than size_t
@@ -2093,7 +2096,7 @@
  * @param data pointer to the beginning of the directory
  * @param offset offset of data in the directory
  * @param dep function to call on each entry
- * @param dep_cls closure for spcb
+ * @param dep_cls closure for dep
  */
 void 
 GNUNET_FS_directory_list_contents (size_t size,