From 29be1a71b26bed8f6b0317cc4ad12195edd6569f Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sun, 5 Mar 2017 15:54:47 +0100 Subject: 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(-) (limited to 'src') 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) -- cgit v1.2.3