[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[GNUnet-SVN] [gnunet] 01/02: indentation, comment and style fixes, no se
|
From: |
gnunet |
|
Subject: |
[GNUnet-SVN] [gnunet] 01/02: indentation, comment and style fixes, no semantic changes |
|
Date: |
Sun, 05 Mar 2017 15:56:17 +0100 |
This is an automated email from the git hooks/post-receive script.
grothoff pushed a commit to branch master
in repository gnunet.
commit 29be1a71b26bed8f6b0317cc4ad12195edd6569f
Author: Christian Grothoff <address@hidden>
AuthorDate: Sun Mar 5 15:54:47 2017 +0100
indentation, comment and style fixes, no semantic changes
---
src/fs/fs_directory.c | 78 +++++++++++++++++++++++++-----------
src/fs/fs_download.c | 108 ++++++++++++++++++++++++++++++++++----------------
src/fs/fs_search.c | 7 ++--
src/fs/fs_tree.c | 6 +--
src/fs/fs_uri.c | 22 ++++++----
5 files changed, 149 insertions(+), 72 deletions(-)
diff --git a/src/fs/fs_directory.c b/src/fs/fs_directory.c
index a18a903be..514eb64b3 100644
--- a/src/fs/fs_directory.c
+++ b/src/fs/fs_directory.c
@@ -170,13 +170,14 @@ find_full_data (void *cls, const char *plugin_name,
* @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 dep
- * @return GNUNET_OK if this could be a block in a directory,
- * GNUNET_NO if this could be part of a directory (but not 100% OK)
- * GNUNET_SYSERR if 'data' does not represent a directory
+ * @param dep_cls closure for @a dep
+ * @return #GNUNET_OK if this could be a block in a directory,
+ * #GNUNET_NO if this could be part of a directory (but not 100% OK)
+ * #GNUNET_SYSERR if @a data does not represent a directory
*/
int
-GNUNET_FS_directory_list_contents (size_t size, const void *data,
+GNUNET_FS_directory_list_contents (size_t size,
+ const void *data,
uint64_t offset,
GNUNET_FS_DirectoryEntryProcessor dep,
void *dep_cls)
@@ -194,12 +195,16 @@ GNUNET_FS_directory_list_contents (size_t size, const
void *data,
if ((offset == 0) &&
((size < 8 + sizeof (uint32_t)) ||
- (0 != memcmp (cdata, GNUNET_FS_DIRECTORY_MAGIC, 8))))
+ (0 != memcmp (cdata,
+ GNUNET_FS_DIRECTORY_MAGIC,
+ 8))))
return GNUNET_SYSERR;
pos = offset;
if (offset == 0)
{
- GNUNET_memcpy (&mdSize, &cdata[8], sizeof (uint32_t));
+ GNUNET_memcpy (&mdSize,
+ &cdata[8],
+ sizeof (uint32_t));
mdSize = ntohl (mdSize);
if (mdSize > size - 8 - sizeof (uint32_t))
{
@@ -215,7 +220,12 @@ GNUNET_FS_directory_list_contents (size_t size, const void
*data,
GNUNET_break (0);
return GNUNET_SYSERR; /* malformed ! */
}
- dep (dep_cls, NULL, NULL, md, 0, NULL);
+ dep (dep_cls,
+ NULL,
+ NULL,
+ md,
+ 0,
+ NULL);
GNUNET_CONTAINER_meta_data_destroy (md);
pos = 8 + sizeof (uint32_t) + mdSize;
}
@@ -247,7 +257,7 @@ GNUNET_FS_directory_list_contents (size_t size, const void
*data,
uri = GNUNET_FS_uri_parse (&cdata[pos], &emsg);
pos = epos + 1;
- if (uri == NULL)
+ if (NULL == uri)
{
GNUNET_free (emsg);
pos--; /* go back to '\0' to force going to next
alignment */
@@ -260,7 +270,9 @@ GNUNET_FS_directory_list_contents (size_t size, const void
*data,
return GNUNET_NO; /* illegal in directory! */
}
- GNUNET_memcpy (&mdSize, &cdata[pos], sizeof (uint32_t));
+ GNUNET_memcpy (&mdSize,
+ &cdata[pos],
+ sizeof (uint32_t));
mdSize = ntohl (mdSize);
pos += sizeof (uint32_t);
if (pos + mdSize > size)
@@ -269,8 +281,9 @@ GNUNET_FS_directory_list_contents (size_t size, const void
*data,
return GNUNET_NO; /* malformed - or partial download */
}
- md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos], mdSize);
- if (md == NULL)
+ md = GNUNET_CONTAINER_meta_data_deserialize (&cdata[pos],
+ mdSize);
+ if (NULL == md)
{
GNUNET_FS_uri_destroy (uri);
GNUNET_break (0);
@@ -282,10 +295,17 @@ GNUNET_FS_directory_list_contents (size_t size, const
void *data,
EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME);
full_data.size = 0;
full_data.data = NULL;
- GNUNET_CONTAINER_meta_data_iterate (md, &find_full_data, &full_data);
- if (dep != NULL)
+ GNUNET_CONTAINER_meta_data_iterate (md,
+ &find_full_data,
+ &full_data);
+ if (NULL != dep)
{
- dep (dep_cls, filename, uri, md, full_data.size, full_data.data);
+ dep (dep_cls,
+ filename,
+ uri,
+ md,
+ full_data.size,
+ full_data.data);
}
GNUNET_free_non_null (full_data.data);
GNUNET_free_non_null (filename);
@@ -548,11 +568,12 @@ block_align (size_t start, unsigned int count, const
size_t * sizes,
* @param bld directory to finish
* @param rsize set to the number of bytes needed
* @param rdata set to the encoded directory
- * @return GNUNET_OK on success
+ * @return #GNUNET_OK on success
*/
int
GNUNET_FS_directory_builder_finish (struct GNUNET_FS_DirectoryBuilder *bld,
- size_t * rsize, void **rdata)
+ size_t * rsize,
+ void **rdata)
{
char *data;
char *sptr;
@@ -575,9 +596,12 @@ GNUNET_FS_directory_builder_finish (struct
GNUNET_FS_DirectoryBuilder *bld,
bes = NULL;
if (0 < bld->count)
{
- sizes = GNUNET_malloc (bld->count * sizeof (size_t));
- perm = GNUNET_malloc (bld->count * sizeof (unsigned int));
- bes = GNUNET_malloc (bld->count * sizeof (struct BuilderEntry *));
+ sizes = GNUNET_new_array (bld->count,
+ size_t);
+ perm = GNUNET_new_array (bld->count,
+ unsigned int);
+ bes = GNUNET_new_array (bld->count,
+ struct BuilderEntry *);
pos = bld->head;
for (i = 0; i < bld->count; i++)
{
@@ -599,7 +623,8 @@ GNUNET_FS_directory_builder_finish (struct
GNUNET_FS_DirectoryBuilder *bld,
data = GNUNET_malloc_large (size);
if (data == NULL)
{
- GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR, "malloc");
+ GNUNET_log_strerror (GNUNET_ERROR_TYPE_ERROR,
+ "malloc");
*rsize = 0;
*rdata = NULL;
GNUNET_free_non_null (sizes);
@@ -608,17 +633,22 @@ GNUNET_FS_directory_builder_finish (struct
GNUNET_FS_DirectoryBuilder *bld,
return GNUNET_SYSERR;
}
*rdata = data;
- GNUNET_memcpy (data, GNUNET_DIRECTORY_MAGIC, strlen
(GNUNET_DIRECTORY_MAGIC));
+ GNUNET_memcpy (data,
+ GNUNET_DIRECTORY_MAGIC,
+ strlen (GNUNET_DIRECTORY_MAGIC));
off = strlen (GNUNET_DIRECTORY_MAGIC);
sptr = &data[off + sizeof (uint32_t)];
ret =
- GNUNET_CONTAINER_meta_data_serialize (bld->meta, &sptr,
+ GNUNET_CONTAINER_meta_data_serialize (bld->meta,
+ &sptr,
size - off - sizeof (uint32_t),
GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
GNUNET_assert (ret != -1);
big = htonl (ret);
- GNUNET_memcpy (&data[off], &big, sizeof (uint32_t));
+ GNUNET_memcpy (&data[off],
+ &big,
+ sizeof (uint32_t));
off += sizeof (uint32_t) + ret;
for (j = 0; j < bld->count; j++)
{
diff --git a/src/fs/fs_download.c b/src/fs/fs_download.c
index 0789162bf..ed24a164a 100644
--- a/src/fs/fs_download.c
+++ b/src/fs/fs_download.c
@@ -37,14 +37,14 @@ static int
is_recursive_download (struct GNUNET_FS_DownloadContext *dc)
{
return (0 != (dc->options & GNUNET_FS_DOWNLOAD_OPTION_RECURSIVE)) &&
- ((GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (dc->meta)) ||
- ((NULL == dc->meta) &&
- ((NULL == dc->filename) ||
- ((strlen (dc->filename) >= strlen (GNUNET_FS_DIRECTORY_EXT)) &&
- (NULL !=
- strstr (dc->filename + strlen (dc->filename) -
- strlen (GNUNET_FS_DIRECTORY_EXT),
- GNUNET_FS_DIRECTORY_EXT))))));
+ ( (GNUNET_YES == GNUNET_FS_meta_data_test_for_directory (dc->meta)) ||
+ ( (NULL == dc->meta) &&
+ ( (NULL == dc->filename) ||
+ ( (strlen (dc->filename) >= strlen (GNUNET_FS_DIRECTORY_EXT)) &&
+ (NULL !=
+ strstr (dc->filename + strlen (dc->filename) -
+ strlen (GNUNET_FS_DIRECTORY_EXT),
+ GNUNET_FS_DIRECTORY_EXT)) ) ) ) );
}
@@ -278,10 +278,12 @@ try_reconnect (struct GNUNET_FS_DownloadContext *dc);
* @param data contents of the file (or NULL if they were not inlined)
*/
static void
-trigger_recursive_download (void *cls, const char *filename,
+trigger_recursive_download (void *cls,
+ const char *filename,
const struct GNUNET_FS_Uri *uri,
const struct GNUNET_CONTAINER_MetaData *meta,
- size_t length, const void *data);
+ size_t length,
+ const void *data);
/**
@@ -304,24 +306,28 @@ full_recursive_download (struct GNUNET_FS_DownloadContext
*dc)
if (size64 != (uint64_t) size)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
- _
- ("Recursive downloads of directories larger than 4 GB are not
supported on 32-bit systems\n"));
+ _("Recursive downloads of directories larger than 4 GB are not
supported on 32-bit systems\n"));
return;
}
if (NULL != dc->filename)
{
- h = GNUNET_DISK_file_open (dc->filename, GNUNET_DISK_OPEN_READ,
+ h = GNUNET_DISK_file_open (dc->filename,
+ GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
}
else
{
GNUNET_assert (NULL != dc->temp_filename);
- h = GNUNET_DISK_file_open (dc->temp_filename, GNUNET_DISK_OPEN_READ,
+ h = GNUNET_DISK_file_open (dc->temp_filename,
+ GNUNET_DISK_OPEN_READ,
GNUNET_DISK_PERM_NONE);
}
if (NULL == h)
return; /* oops */
- data = GNUNET_DISK_file_map (h, &m, GNUNET_DISK_MAP_TYPE_READ, size);
+ data = GNUNET_DISK_file_map (h,
+ &m,
+ GNUNET_DISK_MAP_TYPE_READ,
+ size);
if (NULL == data)
{
GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
@@ -329,15 +335,25 @@ full_recursive_download (struct GNUNET_FS_DownloadContext
*dc)
}
else
{
- GNUNET_FS_directory_list_contents (size, data, 0,
- &trigger_recursive_download, dc);
+ if (GNUNET_OK !=
+ GNUNET_FS_directory_list_contents (size,
+ data,
+ 0,
+ &trigger_recursive_download,
+ dc))
+ {
+ GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
+ _("Failed to access full directroy contents of `%s' for
recursive download\n"),
+ dc->filename);
+ }
GNUNET_DISK_file_unmap (m);
}
GNUNET_DISK_file_close (h);
if (NULL == dc->filename)
{
if (0 != UNLINK (dc->temp_filename))
- GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING, "unlink",
+ GNUNET_log_strerror_file (GNUNET_ERROR_TYPE_WARNING,
+ "unlink",
dc->temp_filename);
GNUNET_free (dc->temp_filename);
dc->temp_filename = NULL;
@@ -362,14 +378,17 @@ check_completed (struct GNUNET_FS_DownloadContext *dc)
struct GNUNET_FS_DownloadContext *pos;
/* first, check if we need to download children */
- if ((NULL == dc->child_head) && (is_recursive_download (dc)))
+ if ( (NULL == dc->child_head) &&
+ (is_recursive_download (dc)) )
full_recursive_download (dc);
/* then, check if children are done already */
for (pos = dc->child_head; NULL != pos; pos = pos->next)
{
- if ((pos->emsg == NULL) && (pos->completed < pos->length))
+ if ( (NULL == pos->emsg) &&
+ (pos->completed < pos->length) )
return; /* not done yet */
- if ((pos->child_head != NULL) && (pos->has_finished != GNUNET_YES))
+ if ( (NULL != pos->child_head) &&
+ (pos->has_finished != GNUNET_YES) )
return; /* not transitively done yet */
}
/* All of our children are done, so mark this download done */
@@ -471,7 +490,11 @@ try_match_block (struct GNUNET_FS_DownloadContext *dc,
}
GNUNET_CRYPTO_hash (&data[dr->offset], dlen, &in_chk.key);
GNUNET_CRYPTO_hash_to_aes_key (&in_chk.key, &sk, &iv);
- if (-1 == GNUNET_CRYPTO_symmetric_encrypt (&data[dr->offset], dlen, &sk,
&iv, enc))
+ if (-1 == GNUNET_CRYPTO_symmetric_encrypt (&data[dr->offset],
+ dlen,
+ &sk,
+ &iv,
+ enc))
{
GNUNET_break (0);
return;
@@ -484,7 +507,9 @@ try_match_block (struct GNUNET_FS_DownloadContext *dc,
dr->state = BRS_RECONSTRUCT_META_UP;
break;
case BRS_CHK_SET:
- if (0 != memcmp (&in_chk, &dr->chk, sizeof (struct ContentHashKey)))
+ if (0 != memcmp (&in_chk,
+ &dr->chk,
+ sizeof (struct ContentHashKey)))
{
/* other peer provided bogus meta data */
GNUNET_break_op (0);
@@ -591,7 +616,10 @@ match_full_data (void *cls, const char *plugin_name,
GNUNET_break_op (0);
return 1; /* bogus meta data */
}
- try_match_block (dc, dc->top_request, data, data_len);
+ try_match_block (dc,
+ dc->top_request,
+ data,
+ data_len);
return 1;
}
@@ -820,10 +848,12 @@ schedule_block_download (struct GNUNET_FS_DownloadContext
*dc,
* @param data contents of the file (or NULL if they were not inlined)
*/
static void
-trigger_recursive_download (void *cls, const char *filename,
+trigger_recursive_download (void *cls,
+ const char *filename,
const struct GNUNET_FS_Uri *uri,
const struct GNUNET_CONTAINER_MetaData *meta,
- size_t length, const void *data)
+ size_t length,
+ const void *data)
{
struct GNUNET_FS_DownloadContext *dc = cls;
struct GNUNET_FS_DownloadContext *cpos;
@@ -936,9 +966,17 @@ trigger_recursive_download (void *cls, const char
*filename,
(unsigned long long) GNUNET_FS_uri_chk_get_file_size (uri),
(unsigned int)
GNUNET_CONTAINER_meta_data_get_serialized_size (meta));
- GNUNET_FS_download_start (dc->h, uri, meta, full_name, temp_name, 0,
+ GNUNET_FS_download_start (dc->h,
+ uri,
+ meta,
+ full_name,
+ temp_name,
+ 0,
GNUNET_FS_uri_chk_get_file_size (uri),
- dc->anonymity, dc->options, NULL, dc);
+ dc->anonymity,
+ dc->options,
+ NULL,
+ dc);
GNUNET_free_non_null (full_name);
GNUNET_free_non_null (temp_name);
GNUNET_free_non_null (fn);
@@ -953,11 +991,9 @@ trigger_recursive_download (void *cls, const char
*filename,
void
GNUNET_FS_free_download_request_ (struct DownloadRequest *dr)
{
- unsigned int i;
-
if (NULL == dr)
return;
- for (i = 0; i < dr->num_children; i++)
+ for (unsigned int i = 0; i < dr->num_children; i++)
GNUNET_FS_free_download_request_ (dr->children[i]);
GNUNET_free_non_null (dr->children);
GNUNET_free (dr);
@@ -1509,13 +1545,17 @@ create_download_request (struct DownloadRequest *parent,
GNUNET_assert (dr->num_children > 0);
dr->children =
- GNUNET_malloc (dr->num_children * sizeof (struct DownloadRequest *));
+ GNUNET_new_array (dr->num_children,
+ struct DownloadRequest *);
for (i = 0; i < dr->num_children; i++)
{
dr->children[i] =
- create_download_request (dr, i + head_skip, depth - 1,
+ create_download_request (dr,
+ i + head_skip,
+ depth - 1,
dr_offset + (i + head_skip) * child_block_size,
- file_start_offset, desired_length);
+ file_start_offset,
+ desired_length);
}
return dr;
}
diff --git a/src/fs/fs_search.c b/src/fs/fs_search.c
index 3cbf2afef..e31115f39 100644
--- a/src/fs/fs_search.c
+++ b/src/fs/fs_search.c
@@ -1383,9 +1383,10 @@ GNUNET_FS_search_start_searching_ (struct
GNUNET_FS_SearchContext *sc)
GNUNET_assert (0 != sc->uri->data.ksk.keywordCount);
anon = GNUNET_CRYPTO_ecdsa_key_get_anonymous ();
GNUNET_CRYPTO_ecdsa_key_get_public (anon, &anon_pub);
- sc->requests =
- GNUNET_malloc (sizeof (struct SearchRequestEntry) *
- sc->uri->data.ksk.keywordCount);
+ sc->requests
+ = GNUNET_new_array (sc->uri->data.ksk.keywordCount,
+ struct SearchRequestEntry);
+
for (i = 0; i < sc->uri->data.ksk.keywordCount; i++)
{
keyword = &sc->uri->data.ksk.keywords[i][1];
diff --git a/src/fs/fs_tree.c b/src/fs/fs_tree.c
index b3c632203..e57e4e494 100644
--- a/src/fs/fs_tree.c
+++ b/src/fs/fs_tree.c
@@ -285,9 +285,9 @@ GNUNET_FS_tree_encoder_create (struct GNUNET_FS_Handle *h,
uint64_t size,
te->progress = progress;
te->cont = cont;
te->chk_tree_depth = GNUNET_FS_compute_depth (size);
- te->chk_tree =
- GNUNET_malloc (te->chk_tree_depth * CHK_PER_INODE *
- sizeof (struct ContentHashKey));
+ te->chk_tree
+ = GNUNET_new_array (te->chk_tree_depth * CHK_PER_INODE,
+ struct ContentHashKey);
GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
"Created tree encoder for file with %llu bytes and depth %u\n",
(unsigned long long) size,
diff --git a/src/fs/fs_uri.c b/src/fs/fs_uri.c
index fa27e6e9b..11968b750 100644
--- a/src/fs/fs_uri.c
+++ b/src/fs/fs_uri.c
@@ -309,7 +309,8 @@ uri_ksk_parse (const char *s,
}
iret = max;
dup = GNUNET_strdup (s);
- keywords = GNUNET_malloc (max * sizeof (char *));
+ keywords = GNUNET_new_array (max,
+ char *);
for (i = slen - 1; i >= (int) pos; i--)
{
if ((s[i] == '%') && (&s[i] == strstr (&s[i], "%22")))
@@ -937,7 +938,8 @@ GNUNET_FS_uri_ksk_merge (const struct GNUNET_FS_Uri *u1,
return NULL;
}
kc = u1->data.ksk.keywordCount;
- kl = GNUNET_malloc ((kc + u2->data.ksk.keywordCount) * sizeof (char *));
+ kl = GNUNET_new_array (kc + u2->data.ksk.keywordCount,
+ 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++)
@@ -991,8 +993,9 @@ GNUNET_FS_uri_dup (const struct GNUNET_FS_Uri *uri)
}
if (ret->data.ksk.keywordCount > 0)
{
- ret->data.ksk.keywords =
- GNUNET_malloc (ret->data.ksk.keywordCount * sizeof (char *));
+ ret->data.ksk.keywords
+ = GNUNET_new_array (ret->data.ksk.keywordCount,
+ char *);
for (i = 0; i < ret->data.ksk.keywordCount; i++)
ret->data.ksk.keywords[i] = GNUNET_strdup (uri->data.ksk.keywords[i]);
}
@@ -1078,7 +1081,8 @@ GNUNET_FS_uri_ksk_create (const char *keywords,
*emsg = GNUNET_strdup (_("Number of double-quotes not balanced!\n"));
return NULL;
}
- keywordarr = GNUNET_malloc (num_Words * sizeof (char *));
+ keywordarr = GNUNET_new_array (num_Words,
+ char *);
num_Words = 0;
inWord = 0;
pos = searchString;
@@ -1151,7 +1155,8 @@ GNUNET_FS_uri_ksk_create_from_args (unsigned int argc,
uri = GNUNET_new (struct GNUNET_FS_Uri);
uri->type = GNUNET_FS_URI_KSK;
uri->data.ksk.keywordCount = argc;
- uri->data.ksk.keywords = GNUNET_malloc (argc * sizeof (char *));
+ uri->data.ksk.keywords = GNUNET_new_array (argc,
+ char *);
for (i = 0; i < argc; i++)
{
keyword = argv[i];
@@ -1766,8 +1771,9 @@ GNUNET_FS_uri_ksk_create_from_meta_data (const struct
GNUNET_CONTAINER_MetaData
}
/* x3 because there might be a normalized variant of every keyword,
plus theoretically one more for mime... */
- ret->data.ksk.keywords = GNUNET_malloc
- (sizeof (char *) * (ent + tok_keywords + paren_keywords) * 3);
+ ret->data.ksk.keywords
+ = GNUNET_new_array ((ent + tok_keywords + paren_keywords) * 3,
+ char *);
GNUNET_CONTAINER_meta_data_iterate (md, &gather_uri_data, ret);
}
if (tok_keywords > 0)
--
To stop receiving notification emails like this one, please contact
address@hidden