}
-
-
/**
* Given a keyword with %-encoding (and possibly quotes to protect
* spaces), return a copy of the keyword without %-encoding and
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;
+}
/**
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;
}
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;
}
* "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;
}
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;
}
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;
}
/**
* Convert binary data to a string.
*
+ * @param data binary data to convert
+ * @param size number of bytes in data
* @return converted data
*/
static char *
}
}
-
-#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 */
* "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);
/**
/* ******************** 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?
* @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
* @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,
projects / oweals / gnunet.git / commitdiff