diff options
author | Christian Grothoff <christian@grothoff.org> | 2016-07-08 17:20:23 +0000 |
---|---|---|
committer | Christian Grothoff <christian@grothoff.org> | 2016-07-08 17:20:23 +0000 |
commit | d8c53b12a818ff7cf82d06a1a69c395bdef85ee6 (patch) | |
tree | 0ebb0db416c157fcfde51a941185819dd12d51fd /src/util | |
parent | 5184c17d32a39c928c2a0fec3ee1ad098bbaa562 (diff) | |
download | gnunet-d8c53b12a818ff7cf82d06a1a69c395bdef85ee6.tar.gz gnunet-d8c53b12a818ff7cf82d06a1a69c395bdef85ee6.zip |
-avoid calling memcpy() with NULL argument, even if len is 0
Diffstat (limited to 'src/util')
34 files changed, 117 insertions, 117 deletions
diff --git a/src/util/bio.c b/src/util/bio.c index 522c28cf8..3de96bb4d 100644 --- a/src/util/bio.c +++ b/src/util/bio.c | |||
@@ -155,7 +155,7 @@ GNUNET_BIO_read (struct GNUNET_BIO_ReadHandle *h, | |||
155 | { | 155 | { |
156 | if (min > len - pos) | 156 | if (min > len - pos) |
157 | min = len - pos; | 157 | min = len - pos; |
158 | memcpy (&dst[pos], &h->buffer[h->pos], min); | 158 | GNUNET_memcpy (&dst[pos], &h->buffer[h->pos], min); |
159 | h->pos += min; | 159 | h->pos += min; |
160 | pos += min; | 160 | pos += min; |
161 | } | 161 | } |
@@ -481,7 +481,7 @@ GNUNET_BIO_write (struct GNUNET_BIO_WriteHandle *h, const void *buffer, | |||
481 | min = h->size - h->have; | 481 | min = h->size - h->have; |
482 | if (min > n - pos) | 482 | if (min > n - pos) |
483 | min = n - pos; | 483 | min = n - pos; |
484 | memcpy (&h->buffer[h->have], &src[pos], min); | 484 | GNUNET_memcpy (&h->buffer[h->have], &src[pos], min); |
485 | pos += min; | 485 | pos += min; |
486 | h->have += min; | 486 | h->have += min; |
487 | if (pos == n) | 487 | if (pos == n) |
diff --git a/src/util/client.c b/src/util/client.c index 8ac3efe88..0ab16a9a1 100644 --- a/src/util/client.c +++ b/src/util/client.c | |||
@@ -586,7 +586,7 @@ receive_helper (void *cls, | |||
586 | if (client->received_size < client->received_pos + available) | 586 | if (client->received_size < client->received_pos + available) |
587 | GNUNET_array_grow (client->received_buf, client->received_size, | 587 | GNUNET_array_grow (client->received_buf, client->received_size, |
588 | client->received_pos + available); | 588 | client->received_pos + available); |
589 | memcpy (&client->received_buf[client->received_pos], buf, available); | 589 | GNUNET_memcpy (&client->received_buf[client->received_pos], buf, available); |
590 | client->received_pos += available; | 590 | client->received_pos += available; |
591 | check_complete (client); | 591 | check_complete (client); |
592 | /* check for timeout */ | 592 | /* check for timeout */ |
@@ -642,7 +642,7 @@ receive_task (void *cls) | |||
642 | client->service_name); | 642 | client->service_name); |
643 | GNUNET_assert (GNUNET_YES == client->msg_complete); | 643 | GNUNET_assert (GNUNET_YES == client->msg_complete); |
644 | GNUNET_assert (client->received_pos >= msize); | 644 | GNUNET_assert (client->received_pos >= msize); |
645 | memcpy (msg, cmsg, msize); | 645 | GNUNET_memcpy (msg, cmsg, msize); |
646 | memmove (client->received_buf, | 646 | memmove (client->received_buf, |
647 | &client->received_buf[msize], | 647 | &client->received_buf[msize], |
648 | client->received_pos - msize); | 648 | client->received_pos - msize); |
@@ -1371,7 +1371,7 @@ transmit_for_response (void *cls, | |||
1371 | return 0; | 1371 | return 0; |
1372 | } | 1372 | } |
1373 | GNUNET_assert (size >= msize); | 1373 | GNUNET_assert (size >= msize); |
1374 | memcpy (buf, tc->hdr, msize); | 1374 | GNUNET_memcpy (buf, tc->hdr, msize); |
1375 | GNUNET_CLIENT_receive (tc->client, | 1375 | GNUNET_CLIENT_receive (tc->client, |
1376 | tc->rn, | 1376 | tc->rn, |
1377 | tc->rn_cls, | 1377 | tc->rn_cls, |
@@ -1420,7 +1420,7 @@ GNUNET_CLIENT_transmit_and_get_response (struct GNUNET_CLIENT_Connection *client | |||
1420 | tc = GNUNET_malloc (sizeof (struct TransmitGetResponseContext) + msize); | 1420 | tc = GNUNET_malloc (sizeof (struct TransmitGetResponseContext) + msize); |
1421 | tc->client = client; | 1421 | tc->client = client; |
1422 | tc->hdr = (const struct GNUNET_MessageHeader *) &tc[1]; | 1422 | tc->hdr = (const struct GNUNET_MessageHeader *) &tc[1]; |
1423 | memcpy (&tc[1], hdr, msize); | 1423 | GNUNET_memcpy (&tc[1], hdr, msize); |
1424 | tc->timeout = GNUNET_TIME_relative_to_absolute (timeout); | 1424 | tc->timeout = GNUNET_TIME_relative_to_absolute (timeout); |
1425 | tc->rn = rn; | 1425 | tc->rn = rn; |
1426 | tc->rn_cls = rn_cls; | 1426 | tc->rn_cls = rn_cls; |
diff --git a/src/util/client_manager.c b/src/util/client_manager.c index 026837841..f444ac24e 100644 --- a/src/util/client_manager.c +++ b/src/util/client_manager.c | |||
@@ -283,7 +283,7 @@ send_next_message (void *cls, size_t buf_size, void *buf) | |||
283 | uint16_t size = ntohs (mqi->msg->size); | 283 | uint16_t size = ntohs (mqi->msg->size); |
284 | mgr->client_tmit = NULL; | 284 | mgr->client_tmit = NULL; |
285 | GNUNET_assert (size <= buf_size); | 285 | GNUNET_assert (size <= buf_size); |
286 | memcpy (buf, mqi->msg, size); | 286 | GNUNET_memcpy (buf, mqi->msg, size); |
287 | 287 | ||
288 | GNUNET_CONTAINER_DLL_remove (mgr->tmit_head, | 288 | GNUNET_CONTAINER_DLL_remove (mgr->tmit_head, |
289 | mgr->tmit_tail, | 289 | mgr->tmit_tail, |
diff --git a/src/util/common_allocation.c b/src/util/common_allocation.c index 95a19f00f..d0ea8d667 100644 --- a/src/util/common_allocation.c +++ b/src/util/common_allocation.c | |||
@@ -124,7 +124,7 @@ GNUNET_xmemdup_ (const void *buf, | |||
124 | ret = &((size_t *) ret)[1]; | 124 | ret = &((size_t *) ret)[1]; |
125 | mem_used += size; | 125 | mem_used += size; |
126 | #endif | 126 | #endif |
127 | memcpy (ret, buf, size); | 127 | GNUNET_memcpy (ret, buf, size); |
128 | return ret; | 128 | return ret; |
129 | } | 129 | } |
130 | 130 | ||
@@ -249,7 +249,7 @@ GNUNET_xfree_ (void *ptr, | |||
249 | 249 | ||
250 | for (i=0;i<s/8;i++) | 250 | for (i=0;i<s/8;i++) |
251 | base[i] = baadfood; | 251 | base[i] = baadfood; |
252 | memcpy (&base[s/8], &baadfood, s % 8); | 252 | GNUNET_memcpy (&base[s/8], &baadfood, s % 8); |
253 | } | 253 | } |
254 | #endif | 254 | #endif |
255 | #endif | 255 | #endif |
@@ -280,7 +280,7 @@ GNUNET_xstrdup_ (const char *str, | |||
280 | res = GNUNET_xmalloc_ (slen, | 280 | res = GNUNET_xmalloc_ (slen, |
281 | filename, | 281 | filename, |
282 | linenumber); | 282 | linenumber); |
283 | memcpy (res, | 283 | GNUNET_memcpy (res, |
284 | str, | 284 | str, |
285 | slen); | 285 | slen); |
286 | return res; | 286 | return res; |
@@ -329,7 +329,7 @@ GNUNET_xstrndup_ (const char *str, | |||
329 | res = GNUNET_xmalloc_ (len + 1, | 329 | res = GNUNET_xmalloc_ (len + 1, |
330 | filename, | 330 | filename, |
331 | linenumber); | 331 | linenumber); |
332 | memcpy (res, str, len); | 332 | GNUNET_memcpy (res, str, len); |
333 | /* res[len] = '\0'; 'malloc' zeros out anyway */ | 333 | /* res[len] = '\0'; 'malloc' zeros out anyway */ |
334 | return res; | 334 | return res; |
335 | } | 335 | } |
@@ -371,7 +371,7 @@ GNUNET_xgrow_ (void **old, | |||
371 | if (*oldCount > newCount) | 371 | if (*oldCount > newCount) |
372 | *oldCount = newCount; /* shrink is also allowed! */ | 372 | *oldCount = newCount; /* shrink is also allowed! */ |
373 | if (NULL != *old) | 373 | if (NULL != *old) |
374 | memcpy (tmp, *old, elementSize * (*oldCount)); | 374 | GNUNET_memcpy (tmp, *old, elementSize * (*oldCount)); |
375 | } | 375 | } |
376 | 376 | ||
377 | if (*old != NULL) | 377 | if (*old != NULL) |
@@ -450,7 +450,7 @@ GNUNET_copy_message (const struct GNUNET_MessageHeader *msg) | |||
450 | msize = ntohs (msg->size); | 450 | msize = ntohs (msg->size); |
451 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); | 451 | GNUNET_assert (msize >= sizeof (struct GNUNET_MessageHeader)); |
452 | ret = GNUNET_malloc (msize); | 452 | ret = GNUNET_malloc (msize); |
453 | memcpy (ret, msg, msize); | 453 | GNUNET_memcpy (ret, msg, msize); |
454 | return ret; | 454 | return ret; |
455 | } | 455 | } |
456 | 456 | ||
diff --git a/src/util/configuration.c b/src/util/configuration.c index 0ddb4fb2f..bc5fd3abd 100644 --- a/src/util/configuration.c +++ b/src/util/configuration.c | |||
@@ -432,7 +432,7 @@ GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
432 | { | 432 | { |
433 | len = GNUNET_asprintf (&cbuf, "[%s]\n", sec->name); | 433 | len = GNUNET_asprintf (&cbuf, "[%s]\n", sec->name); |
434 | GNUNET_assert (0 < len); | 434 | GNUNET_assert (0 < len); |
435 | memcpy (mem + c_size, cbuf, len); | 435 | GNUNET_memcpy (mem + c_size, cbuf, len); |
436 | c_size += len; | 436 | c_size += len; |
437 | GNUNET_free (cbuf); | 437 | GNUNET_free (cbuf); |
438 | for (ent = sec->entries; NULL != ent; ent = ent->next) | 438 | for (ent = sec->entries; NULL != ent; ent = ent->next) |
@@ -449,12 +449,12 @@ GNUNET_CONFIGURATION_serialize (const struct GNUNET_CONFIGURATION_Handle *cfg, | |||
449 | } | 449 | } |
450 | len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val); | 450 | len = GNUNET_asprintf (&cbuf, "%s = %s\n", ent->key, val); |
451 | GNUNET_free (val); | 451 | GNUNET_free (val); |
452 | memcpy (mem + c_size, cbuf, len); | 452 | GNUNET_memcpy (mem + c_size, cbuf, len); |
453 | c_size += len; | 453 | c_size += len; |
454 | GNUNET_free (cbuf); | 454 | GNUNET_free (cbuf); |
455 | } | 455 | } |
456 | } | 456 | } |
457 | memcpy (mem + c_size, "\n", 1); | 457 | GNUNET_memcpy (mem + c_size, "\n", 1); |
458 | c_size ++; | 458 | c_size ++; |
459 | sec = sec->next; | 459 | sec = sec->next; |
460 | } | 460 | } |
@@ -1291,7 +1291,7 @@ GNUNET_CONFIGURATION_expand_dollar (const struct GNUNET_CONFIGURATION_Handle *cf | |||
1291 | dup = expand_dollar (cfg, dup, 0); | 1291 | dup = expand_dollar (cfg, dup, 0); |
1292 | len = strlen (dup) + 1; | 1292 | len = strlen (dup) + 1; |
1293 | orig = GNUNET_realloc (orig, i + len); | 1293 | orig = GNUNET_realloc (orig, i + len); |
1294 | memcpy (orig + i, dup, len); | 1294 | GNUNET_memcpy (orig + i, dup, len); |
1295 | GNUNET_free (dup); | 1295 | GNUNET_free (dup); |
1296 | } | 1296 | } |
1297 | return orig; | 1297 | return orig; |
diff --git a/src/util/connection.c b/src/util/connection.c index 95fbb13f8..6d3070415 100644 --- a/src/util/connection.c +++ b/src/util/connection.c | |||
@@ -372,7 +372,7 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb, | |||
372 | #if HAVE_SOCKADDR_IN_SIN_LEN | 372 | #if HAVE_SOCKADDR_IN_SIN_LEN |
373 | v4->sin_len = (u_char) sizeof (struct sockaddr_in); | 373 | v4->sin_len = (u_char) sizeof (struct sockaddr_in); |
374 | #endif | 374 | #endif |
375 | memcpy (&v4->sin_addr, | 375 | GNUNET_memcpy (&v4->sin_addr, |
376 | &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) - | 376 | &((char *) &v6->sin6_addr)[sizeof (struct in6_addr) - |
377 | sizeof (struct in_addr)], | 377 | sizeof (struct in_addr)], |
378 | sizeof (struct in_addr)); | 378 | sizeof (struct in_addr)); |
@@ -383,7 +383,7 @@ GNUNET_CONNECTION_create_from_accept (GNUNET_CONNECTION_AccessCheck access_cb, | |||
383 | else | 383 | else |
384 | { | 384 | { |
385 | uaddr = GNUNET_malloc (addrlen); | 385 | uaddr = GNUNET_malloc (addrlen); |
386 | memcpy (uaddr, addr, addrlen); | 386 | GNUNET_memcpy (uaddr, addr, addrlen); |
387 | } | 387 | } |
388 | gcp = NULL; | 388 | gcp = NULL; |
389 | gc.uid = 0; | 389 | gc.uid = 0; |
@@ -479,7 +479,7 @@ GNUNET_CONNECTION_get_address (struct GNUNET_CONNECTION_Handle *connection, | |||
479 | if ((NULL == connection->addr) || (0 == connection->addrlen)) | 479 | if ((NULL == connection->addr) || (0 == connection->addrlen)) |
480 | return GNUNET_NO; | 480 | return GNUNET_NO; |
481 | *addr = GNUNET_malloc (connection->addrlen); | 481 | *addr = GNUNET_malloc (connection->addrlen); |
482 | memcpy (*addr, connection->addr, connection->addrlen); | 482 | GNUNET_memcpy (*addr, connection->addr, connection->addrlen); |
483 | *addrlen = connection->addrlen; | 483 | *addrlen = connection->addrlen; |
484 | return GNUNET_OK; | 484 | return GNUNET_OK; |
485 | } | 485 | } |
@@ -726,7 +726,7 @@ connect_probe_continuation (void *cls) | |||
726 | connection->sock = ap->sock; | 726 | connection->sock = ap->sock; |
727 | GNUNET_assert (NULL == connection->addr); | 727 | GNUNET_assert (NULL == connection->addr); |
728 | connection->addr = GNUNET_malloc (ap->addrlen); | 728 | connection->addr = GNUNET_malloc (ap->addrlen); |
729 | memcpy (connection->addr, ap->addr, ap->addrlen); | 729 | GNUNET_memcpy (connection->addr, ap->addr, ap->addrlen); |
730 | connection->addrlen = ap->addrlen; | 730 | connection->addrlen = ap->addrlen; |
731 | GNUNET_free (ap); | 731 | GNUNET_free (ap); |
732 | /* cancel all other attempts */ | 732 | /* cancel all other attempts */ |
@@ -781,7 +781,7 @@ try_connect_using_address (void *cls, | |||
781 | connection->port); | 781 | connection->port); |
782 | ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen); | 782 | ap = GNUNET_malloc (sizeof (struct AddressProbe) + addrlen); |
783 | ap->addr = (const struct sockaddr *) &ap[1]; | 783 | ap->addr = (const struct sockaddr *) &ap[1]; |
784 | memcpy (&ap[1], addr, addrlen); | 784 | GNUNET_memcpy (&ap[1], addr, addrlen); |
785 | ap->addrlen = addrlen; | 785 | ap->addrlen = addrlen; |
786 | ap->connection = connection; | 786 | ap->connection = connection; |
787 | 787 | ||
@@ -976,7 +976,7 @@ GNUNET_CONNECTION_connect_socket (struct GNUNET_NETWORK_Handle *s, | |||
976 | } | 976 | } |
977 | connection = GNUNET_CONNECTION_create_from_existing (s); | 977 | connection = GNUNET_CONNECTION_create_from_existing (s); |
978 | connection->addr = GNUNET_malloc (addrlen); | 978 | connection->addr = GNUNET_malloc (addrlen); |
979 | memcpy (connection->addr, serv_addr, addrlen); | 979 | GNUNET_memcpy (connection->addr, serv_addr, addrlen); |
980 | connection->addrlen = addrlen; | 980 | connection->addrlen = addrlen; |
981 | LOG (GNUNET_ERROR_TYPE_INFO, | 981 | LOG (GNUNET_ERROR_TYPE_INFO, |
982 | "Trying to connect to `%s' (%p)\n", | 982 | "Trying to connect to `%s' (%p)\n", |
diff --git a/src/util/container_bloomfilter.c b/src/util/container_bloomfilter.c index 96e15320d..58725dcc5 100644 --- a/src/util/container_bloomfilter.c +++ b/src/util/container_bloomfilter.c | |||
@@ -643,7 +643,7 @@ GNUNET_CONTAINER_bloomfilter_init (const char *data, size_t size, | |||
643 | bf->bitArraySize = size; | 643 | bf->bitArraySize = size; |
644 | bf->addressesPerElement = k; | 644 | bf->addressesPerElement = k; |
645 | if (NULL != data) | 645 | if (NULL != data) |
646 | memcpy (bf->bitArray, data, size); | 646 | GNUNET_memcpy (bf->bitArray, data, size); |
647 | return bf; | 647 | return bf; |
648 | } | 648 | } |
649 | 649 | ||
@@ -666,7 +666,7 @@ GNUNET_CONTAINER_bloomfilter_get_raw_data (const struct | |||
666 | return GNUNET_SYSERR; | 666 | return GNUNET_SYSERR; |
667 | if (bf->bitArraySize != size) | 667 | if (bf->bitArraySize != size) |
668 | return GNUNET_SYSERR; | 668 | return GNUNET_SYSERR; |
669 | memcpy (data, bf->bitArray, size); | 669 | GNUNET_memcpy (data, bf->bitArray, size); |
670 | return GNUNET_OK; | 670 | return GNUNET_OK; |
671 | } | 671 | } |
672 | 672 | ||
diff --git a/src/util/container_meta_data.c b/src/util/container_meta_data.c index 647cc1d60..d7c5ddb11 100644 --- a/src/util/container_meta_data.c +++ b/src/util/container_meta_data.c | |||
@@ -406,7 +406,7 @@ GNUNET_CONTAINER_meta_data_insert (struct GNUNET_CONTAINER_MetaData *md, | |||
406 | (NULL == data_mime_type) ? NULL : GNUNET_strdup (data_mime_type); | 406 | (NULL == data_mime_type) ? NULL : GNUNET_strdup (data_mime_type); |
407 | mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup (plugin_name); | 407 | mi->plugin_name = (NULL == plugin_name) ? NULL : GNUNET_strdup (plugin_name); |
408 | mi->data = GNUNET_malloc (data_size); | 408 | mi->data = GNUNET_malloc (data_size); |
409 | memcpy (mi->data, data, data_size); | 409 | GNUNET_memcpy (mi->data, data, data_size); |
410 | /* change all dir separators to POSIX style ('/') */ | 410 | /* change all dir separators to POSIX style ('/') */ |
411 | if ( (EXTRACTOR_METATYPE_FILENAME == type) || | 411 | if ( (EXTRACTOR_METATYPE_FILENAME == type) || |
412 | (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type) ) | 412 | (EXTRACTOR_METATYPE_GNUNET_ORIGINAL_FILENAME == type) ) |
@@ -656,7 +656,7 @@ GNUNET_CONTAINER_meta_data_get_thumbnail (const struct GNUNET_CONTAINER_MetaData | |||
656 | if ((NULL == match) || (0 == match->data_size)) | 656 | if ((NULL == match) || (0 == match->data_size)) |
657 | return 0; | 657 | return 0; |
658 | *thumb = GNUNET_malloc (match->data_size); | 658 | *thumb = GNUNET_malloc (match->data_size); |
659 | memcpy (*thumb, match->data, match->data_size); | 659 | GNUNET_memcpy (*thumb, match->data, match->data_size); |
660 | return match->data_size; | 660 | return match->data_size; |
661 | } | 661 | } |
662 | 662 | ||
@@ -816,7 +816,7 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
816 | { | 816 | { |
817 | if (NULL == *target) | 817 | if (NULL == *target) |
818 | *target = GNUNET_malloc (md->sbuf_size); | 818 | *target = GNUNET_malloc (md->sbuf_size); |
819 | memcpy (*target, md->sbuf, md->sbuf_size); | 819 | GNUNET_memcpy (*target, md->sbuf, md->sbuf_size); |
820 | return md->sbuf_size; | 820 | return md->sbuf_size; |
821 | } | 821 | } |
822 | if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART)) | 822 | if (0 == (opt & GNUNET_CONTAINER_META_DATA_SERIALIZE_PART)) |
@@ -868,13 +868,13 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
868 | if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) || | 868 | if ((EXTRACTOR_METAFORMAT_UTF8 == pos->format) || |
869 | (EXTRACTOR_METAFORMAT_C_STRING == pos->format)) | 869 | (EXTRACTOR_METAFORMAT_C_STRING == pos->format)) |
870 | GNUNET_break ('\0' == pos->data[pos->data_size - 1]); | 870 | GNUNET_break ('\0' == pos->data[pos->data_size - 1]); |
871 | memcpy (&mdata[off], pos->data, pos->data_size); | 871 | GNUNET_memcpy (&mdata[off], pos->data, pos->data_size); |
872 | off -= plen; | 872 | off -= plen; |
873 | if (NULL != pos->plugin_name) | 873 | if (NULL != pos->plugin_name) |
874 | memcpy (&mdata[off], pos->plugin_name, plen); | 874 | GNUNET_memcpy (&mdata[off], pos->plugin_name, plen); |
875 | off -= mlen; | 875 | off -= mlen; |
876 | if (NULL != pos->mime_type) | 876 | if (NULL != pos->mime_type) |
877 | memcpy (&mdata[off], pos->mime_type, mlen); | 877 | GNUNET_memcpy (&mdata[off], pos->mime_type, mlen); |
878 | i++; | 878 | i++; |
879 | } | 879 | } |
880 | GNUNET_assert (0 == off); | 880 | GNUNET_assert (0 == off); |
@@ -905,13 +905,13 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
905 | { | 905 | { |
906 | GNUNET_assert (clen < left); | 906 | GNUNET_assert (clen < left); |
907 | hdr->version = htonl (2 | HEADER_COMPRESSED); | 907 | hdr->version = htonl (2 | HEADER_COMPRESSED); |
908 | memcpy (&hdr[1], cdata, clen); | 908 | GNUNET_memcpy (&hdr[1], cdata, clen); |
909 | vmd->sbuf_size = clen + sizeof (struct MetaDataHeader); | 909 | vmd->sbuf_size = clen + sizeof (struct MetaDataHeader); |
910 | } | 910 | } |
911 | else | 911 | else |
912 | { | 912 | { |
913 | hdr->version = htonl (2); | 913 | hdr->version = htonl (2); |
914 | memcpy (&hdr[1], &ent[0], left); | 914 | GNUNET_memcpy (&hdr[1], &ent[0], left); |
915 | vmd->sbuf_size = left + sizeof (struct MetaDataHeader); | 915 | vmd->sbuf_size = left + sizeof (struct MetaDataHeader); |
916 | } | 916 | } |
917 | vmd->sbuf = (char *) hdr; | 917 | vmd->sbuf = (char *) hdr; |
@@ -929,7 +929,7 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
929 | hdr->version = htonl (2 | HEADER_COMPRESSED); | 929 | hdr->version = htonl (2 | HEADER_COMPRESSED); |
930 | hdr->size = htonl (left); | 930 | hdr->size = htonl (left); |
931 | hdr->entries = htonl (md->item_count - i); | 931 | hdr->entries = htonl (md->item_count - i); |
932 | memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen); | 932 | GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], cdata, clen); |
933 | GNUNET_free (cdata); | 933 | GNUNET_free (cdata); |
934 | cdata = NULL; | 934 | cdata = NULL; |
935 | GNUNET_free (ent); | 935 | GNUNET_free (ent); |
@@ -943,16 +943,16 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
943 | hdr->version = htonl (2); | 943 | hdr->version = htonl (2); |
944 | hdr->entries = htonl (md->item_count - i); | 944 | hdr->entries = htonl (md->item_count - i); |
945 | hdr->size = htonl (left); | 945 | hdr->size = htonl (left); |
946 | memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left); | 946 | GNUNET_memcpy (&dst[sizeof (struct MetaDataHeader)], &ent[i], left); |
947 | GNUNET_free (ent); | 947 | GNUNET_free (ent); |
948 | rlen = left + sizeof (struct MetaDataHeader); | 948 | rlen = left + sizeof (struct MetaDataHeader); |
949 | } | 949 | } |
950 | if (NULL != *target) | 950 | if (NULL != *target) |
951 | { | 951 | { |
952 | if (GNUNET_YES == comp) | 952 | if (GNUNET_YES == comp) |
953 | memcpy (*target, dst, clen + sizeof (struct MetaDataHeader)); | 953 | GNUNET_memcpy (*target, dst, clen + sizeof (struct MetaDataHeader)); |
954 | else | 954 | else |
955 | memcpy (*target, dst, left + sizeof (struct MetaDataHeader)); | 955 | GNUNET_memcpy (*target, dst, left + sizeof (struct MetaDataHeader)); |
956 | GNUNET_free (dst); | 956 | GNUNET_free (dst); |
957 | } | 957 | } |
958 | else | 958 | else |
@@ -991,7 +991,7 @@ GNUNET_CONTAINER_meta_data_serialize (const struct GNUNET_CONTAINER_MetaData | |||
991 | ihdr.size = htonl (0); | 991 | ihdr.size = htonl (0); |
992 | if (NULL == *target) | 992 | if (NULL == *target) |
993 | *target = (char *) GNUNET_new (struct MetaDataHeader); | 993 | *target = (char *) GNUNET_new (struct MetaDataHeader); |
994 | memcpy (*target, &ihdr, sizeof (struct MetaDataHeader)); | 994 | GNUNET_memcpy (*target, &ihdr, sizeof (struct MetaDataHeader)); |
995 | return sizeof (struct MetaDataHeader); | 995 | return sizeof (struct MetaDataHeader); |
996 | } | 996 | } |
997 | 997 | ||
@@ -1054,7 +1054,7 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size) | |||
1054 | 1054 | ||
1055 | if (size < sizeof (struct MetaDataHeader)) | 1055 | if (size < sizeof (struct MetaDataHeader)) |
1056 | return NULL; | 1056 | return NULL; |
1057 | memcpy (&hdr, input, sizeof (struct MetaDataHeader)); | 1057 | GNUNET_memcpy (&hdr, input, sizeof (struct MetaDataHeader)); |
1058 | version = ntohl (hdr.version) & HEADER_VERSION_MASK; | 1058 | version = ntohl (hdr.version) & HEADER_VERSION_MASK; |
1059 | compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0; | 1059 | compressed = (ntohl (hdr.version) & HEADER_COMPRESSED) != 0; |
1060 | 1060 | ||
@@ -1112,7 +1112,7 @@ GNUNET_CONTAINER_meta_data_deserialize (const char *input, size_t size) | |||
1112 | mdata = &cdata[ic * sizeof (struct MetaDataEntry)]; | 1112 | mdata = &cdata[ic * sizeof (struct MetaDataEntry)]; |
1113 | for (i = 0; i < ic; i++) | 1113 | for (i = 0; i < ic; i++) |
1114 | { | 1114 | { |
1115 | memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)], | 1115 | GNUNET_memcpy (&ent, &cdata[i * sizeof (struct MetaDataEntry)], |
1116 | sizeof (struct MetaDataEntry)); | 1116 | sizeof (struct MetaDataEntry)); |
1117 | format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format); | 1117 | format = (enum EXTRACTOR_MetaFormat) ntohl (ent.format); |
1118 | if ((EXTRACTOR_METAFORMAT_UTF8 != format) && | 1118 | if ((EXTRACTOR_METAFORMAT_UTF8 != format) && |
diff --git a/src/util/container_multipeermap.c b/src/util/container_multipeermap.c index 64ef26928..6c62e7403 100644 --- a/src/util/container_multipeermap.c +++ b/src/util/container_multipeermap.c | |||
@@ -248,7 +248,7 @@ idx_of (const struct GNUNET_CONTAINER_MultiPeerMap *map, | |||
248 | unsigned int kx; | 248 | unsigned int kx; |
249 | 249 | ||
250 | GNUNET_assert (NULL != map); | 250 | GNUNET_assert (NULL != map); |
251 | memcpy (&kx, key, sizeof (kx)); | 251 | GNUNET_memcpy (&kx, key, sizeof (kx)); |
252 | return kx % map->map_length; | 252 | return kx % map->map_length; |
253 | } | 253 | } |
254 | 254 | ||
diff --git a/src/util/crypto_hash.c b/src/util/crypto_hash.c index 140448459..31824e72a 100644 --- a/src/util/crypto_hash.c +++ b/src/util/crypto_hash.c | |||
@@ -396,7 +396,7 @@ GNUNET_CRYPTO_hmac (const struct GNUNET_CRYPTO_AuthKey *key, | |||
396 | gcry_md_write (md, plaintext, plaintext_len); | 396 | gcry_md_write (md, plaintext, plaintext_len); |
397 | mc = gcry_md_read (md, GCRY_MD_SHA512); | 397 | mc = gcry_md_read (md, GCRY_MD_SHA512); |
398 | GNUNET_assert (NULL != mc); | 398 | GNUNET_assert (NULL != mc); |
399 | memcpy (hmac->bits, mc, sizeof (hmac->bits)); | 399 | GNUNET_memcpy (hmac->bits, mc, sizeof (hmac->bits)); |
400 | } | 400 | } |
401 | 401 | ||
402 | 402 | ||
@@ -461,7 +461,7 @@ GNUNET_CRYPTO_hash_context_finish (struct GNUNET_HashContext *hc, | |||
461 | 461 | ||
462 | GNUNET_assert (NULL != res); | 462 | GNUNET_assert (NULL != res); |
463 | if (NULL != r_hash) | 463 | if (NULL != r_hash) |
464 | memcpy (r_hash, | 464 | GNUNET_memcpy (r_hash, |
465 | res, | 465 | res, |
466 | sizeof (struct GNUNET_HashCode)); | 466 | sizeof (struct GNUNET_HashCode)); |
467 | GNUNET_CRYPTO_hash_context_abort (hc); | 467 | GNUNET_CRYPTO_hash_context_abort (hc); |
diff --git a/src/util/crypto_hkdf.c b/src/util/crypto_hkdf.c index fa2bd1a69..c6c43f800 100644 --- a/src/util/crypto_hkdf.c +++ b/src/util/crypto_hkdf.c | |||
@@ -102,7 +102,7 @@ getPRK (gcry_md_hd_t mac, const void *xts, size_t xts_len, const void *skm, | |||
102 | ret = doHMAC (mac, xts, xts_len, skm, skm_len); | 102 | ret = doHMAC (mac, xts, xts_len, skm, skm_len); |
103 | if (ret == NULL) | 103 | if (ret == NULL) |
104 | return GNUNET_SYSERR; | 104 | return GNUNET_SYSERR; |
105 | memcpy (prk, ret, gcry_md_get_algo_dlen (gcry_md_get_algo (mac))); | 105 | GNUNET_memcpy (prk, ret, gcry_md_get_algo_dlen (gcry_md_get_algo (mac))); |
106 | 106 | ||
107 | return GNUNET_YES; | 107 | return GNUNET_YES; |
108 | } | 108 | } |
@@ -198,7 +198,7 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, | |||
198 | size_t len; | 198 | size_t len; |
199 | 199 | ||
200 | len = va_arg (args, size_t); | 200 | len = va_arg (args, size_t); |
201 | memcpy (dst, ctx, len); | 201 | GNUNET_memcpy (dst, ctx, len); |
202 | dst += len; | 202 | dst += len; |
203 | } | 203 | } |
204 | va_end (args); | 204 | va_end (args); |
@@ -212,14 +212,14 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, | |||
212 | hc = doHMAC (prf, prk, xtr_len, &plain[k], ctx_len + 1); | 212 | hc = doHMAC (prf, prk, xtr_len, &plain[k], ctx_len + 1); |
213 | if (hc == NULL) | 213 | if (hc == NULL) |
214 | goto hkdf_error; | 214 | goto hkdf_error; |
215 | memcpy (result, hc, k); | 215 | GNUNET_memcpy (result, hc, k); |
216 | result += k; | 216 | result += k; |
217 | } | 217 | } |
218 | 218 | ||
219 | /* K(i+1) */ | 219 | /* K(i+1) */ |
220 | for (i = 1; i < t; i++) | 220 | for (i = 1; i < t; i++) |
221 | { | 221 | { |
222 | memcpy (plain, result - k, k); | 222 | GNUNET_memcpy (plain, result - k, k); |
223 | memset (plain + k + ctx_len, i + 1, 1); | 223 | memset (plain + k + ctx_len, i + 1, 1); |
224 | gcry_md_reset (prf); | 224 | gcry_md_reset (prf); |
225 | #if DEBUG_HKDF | 225 | #if DEBUG_HKDF |
@@ -228,7 +228,7 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, | |||
228 | hc = doHMAC (prf, prk, xtr_len, plain, plain_len); | 228 | hc = doHMAC (prf, prk, xtr_len, plain, plain_len); |
229 | if (hc == NULL) | 229 | if (hc == NULL) |
230 | goto hkdf_error; | 230 | goto hkdf_error; |
231 | memcpy (result, hc, k); | 231 | GNUNET_memcpy (result, hc, k); |
232 | result += k; | 232 | result += k; |
233 | } | 233 | } |
234 | 234 | ||
@@ -237,7 +237,7 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, | |||
237 | { | 237 | { |
238 | if (t > 0) | 238 | if (t > 0) |
239 | { | 239 | { |
240 | memcpy (plain, result - k, k); | 240 | GNUNET_memcpy (plain, result - k, k); |
241 | i++; | 241 | i++; |
242 | } | 242 | } |
243 | memset (plain + k + ctx_len, i, 1); | 243 | memset (plain + k + ctx_len, i, 1); |
@@ -251,7 +251,7 @@ GNUNET_CRYPTO_hkdf_v (void *result, size_t out_len, int xtr_algo, int prf_algo, | |||
251 | hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k); | 251 | hc = doHMAC (prf, prk, xtr_len, plain + k, plain_len - k); |
252 | if (hc == NULL) | 252 | if (hc == NULL) |
253 | goto hkdf_error; | 253 | goto hkdf_error; |
254 | memcpy (result, hc, d); | 254 | GNUNET_memcpy (result, hc, d); |
255 | } | 255 | } |
256 | #if DEBUG_HKDF | 256 | #if DEBUG_HKDF |
257 | dump ("result", result - k, out_len); | 257 | dump ("result", result - k, out_len); |
diff --git a/src/util/crypto_mpi.c b/src/util/crypto_mpi.c index 15ce57586..668d5e602 100644 --- a/src/util/crypto_mpi.c +++ b/src/util/crypto_mpi.c | |||
@@ -90,7 +90,7 @@ GNUNET_CRYPTO_mpi_print_unsigned (void *buf, | |||
90 | rsize = (nbits+7)/8; | 90 | rsize = (nbits+7)/8; |
91 | if (rsize > size) | 91 | if (rsize > size) |
92 | rsize = size; | 92 | rsize = size; |
93 | memcpy (buf, p, rsize); | 93 | GNUNET_memcpy (buf, p, rsize); |
94 | if (rsize < size) | 94 | if (rsize < size) |
95 | memset (buf+rsize, 0, size - rsize); | 95 | memset (buf+rsize, 0, size - rsize); |
96 | } | 96 | } |
diff --git a/src/util/crypto_symmetric.c b/src/util/crypto_symmetric.c index 58ad33170..381a5d2f8 100644 --- a/src/util/crypto_symmetric.c +++ b/src/util/crypto_symmetric.c | |||
@@ -223,10 +223,10 @@ GNUNET_CRYPTO_symmetric_derive_iv_v (struct GNUNET_CRYPTO_SymmetricInitializatio | |||
223 | char aes_salt[salt_len + 4]; | 223 | char aes_salt[salt_len + 4]; |
224 | char twofish_salt[salt_len + 4]; | 224 | char twofish_salt[salt_len + 4]; |
225 | 225 | ||
226 | memcpy (aes_salt, salt, salt_len); | 226 | GNUNET_memcpy (aes_salt, salt, salt_len); |
227 | memcpy (&aes_salt[salt_len], "AES!", 4); | 227 | GNUNET_memcpy (&aes_salt[salt_len], "AES!", 4); |
228 | memcpy (twofish_salt, salt, salt_len); | 228 | GNUNET_memcpy (twofish_salt, salt, salt_len); |
229 | memcpy (&twofish_salt[salt_len], "FISH", 4); | 229 | GNUNET_memcpy (&twofish_salt[salt_len], "FISH", 4); |
230 | GNUNET_CRYPTO_kdf_v (iv->aes_iv, | 230 | GNUNET_CRYPTO_kdf_v (iv->aes_iv, |
231 | sizeof (iv->aes_iv), | 231 | sizeof (iv->aes_iv), |
232 | aes_salt, | 232 | aes_salt, |
diff --git a/src/util/getopt_helpers.c b/src/util/getopt_helpers.c index 5a0bf0565..ab0b67412 100644 --- a/src/util/getopt_helpers.c +++ b/src/util/getopt_helpers.c | |||
@@ -129,7 +129,7 @@ OUTER: | |||
129 | if (isspace ((unsigned char) trans[j])) | 129 | if (isspace ((unsigned char) trans[j])) |
130 | { | 130 | { |
131 | scp = GNUNET_malloc (j - p + 1); | 131 | scp = GNUNET_malloc (j - p + 1); |
132 | memcpy (scp, &trans[p], j - p); | 132 | GNUNET_memcpy (scp, &trans[p], j - p); |
133 | scp[j - p] = '\0'; | 133 | scp[j - p] = '\0'; |
134 | printf ("%s\n%*s", scp, BORDER + 2, ""); | 134 | printf ("%s\n%*s", scp, BORDER + 2, ""); |
135 | GNUNET_free (scp); | 135 | GNUNET_free (scp); |
@@ -140,7 +140,7 @@ OUTER: | |||
140 | } | 140 | } |
141 | /* could not find space to break line */ | 141 | /* could not find space to break line */ |
142 | scp = GNUNET_malloc (78 - slen + 1); | 142 | scp = GNUNET_malloc (78 - slen + 1); |
143 | memcpy (scp, &trans[p], 78 - slen); | 143 | GNUNET_memcpy (scp, &trans[p], 78 - slen); |
144 | scp[78 - slen] = '\0'; | 144 | scp[78 - slen] = '\0'; |
145 | printf ("%s\n%*s", scp, BORDER + 2, ""); | 145 | printf ("%s\n%*s", scp, BORDER + 2, ""); |
146 | GNUNET_free (scp); | 146 | GNUNET_free (scp); |
diff --git a/src/util/gnunet-ecc.c b/src/util/gnunet-ecc.c index 6d352e3ab..ddfd9b1c3 100644 --- a/src/util/gnunet-ecc.c +++ b/src/util/gnunet-ecc.c | |||
@@ -323,7 +323,7 @@ print_key (const char *filename) | |||
323 | total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE; | 323 | total_hostkeys = fs / GNUNET_TESTING_HOSTKEYFILESIZE; |
324 | for (c = 0; (c < total_hostkeys) && (c < list_keys_count); c++) | 324 | for (c = 0; (c < total_hostkeys) && (c < list_keys_count); c++) |
325 | { | 325 | { |
326 | memcpy (&private_key, | 326 | GNUNET_memcpy (&private_key, |
327 | hostkeys_data + (c * GNUNET_TESTING_HOSTKEYFILESIZE), | 327 | hostkeys_data + (c * GNUNET_TESTING_HOSTKEYFILESIZE), |
328 | GNUNET_TESTING_HOSTKEYFILESIZE); | 328 | GNUNET_TESTING_HOSTKEYFILESIZE); |
329 | GNUNET_CRYPTO_eddsa_key_get_public (&private_key, &public_key); | 329 | GNUNET_CRYPTO_eddsa_key_get_public (&private_key, &public_key); |
diff --git a/src/util/gnunet-scrypt.c b/src/util/gnunet-scrypt.c index faf04cf27..ab0cf92e0 100644 --- a/src/util/gnunet-scrypt.c +++ b/src/util/gnunet-scrypt.c | |||
@@ -131,14 +131,14 @@ find_proof (void *cls) | |||
131 | "Got Proof of Work %llu\n", | 131 | "Got Proof of Work %llu\n", |
132 | (unsigned long long) proof); | 132 | (unsigned long long) proof); |
133 | proof_task = NULL; | 133 | proof_task = NULL; |
134 | memcpy (&buf[sizeof (uint64_t)], &pub, | 134 | GNUNET_memcpy (&buf[sizeof (uint64_t)], &pub, |
135 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); | 135 | sizeof (struct GNUNET_CRYPTO_EddsaPublicKey)); |
136 | i = 0; | 136 | i = 0; |
137 | counter = proof; | 137 | counter = proof; |
138 | timestamp = GNUNET_TIME_absolute_get (); | 138 | timestamp = GNUNET_TIME_absolute_get (); |
139 | while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) | 139 | while ((counter != UINT64_MAX) && (i < ROUND_SIZE)) |
140 | { | 140 | { |
141 | memcpy (buf, &counter, sizeof (uint64_t)); | 141 | GNUNET_memcpy (buf, &counter, sizeof (uint64_t)); |
142 | pow_hash (buf, sizeof (buf), &result); | 142 | pow_hash (buf, sizeof (buf), &result); |
143 | if (nse_work_required <= count_leading_zeroes (&result)) | 143 | if (nse_work_required <= count_leading_zeroes (&result)) |
144 | { | 144 | { |
diff --git a/src/util/gnunet-service-resolver.c b/src/util/gnunet-service-resolver.c index 1ff9ae298..a87b1f5d0 100644 --- a/src/util/gnunet-service-resolver.c +++ b/src/util/gnunet-service-resolver.c | |||
@@ -267,7 +267,7 @@ get_ip_as_string (struct GNUNET_SERVER_Client *client, | |||
267 | { | 267 | { |
268 | pos = GNUNET_malloc (sizeof (struct IPCache) + ip_len); | 268 | pos = GNUNET_malloc (sizeof (struct IPCache) + ip_len); |
269 | pos->ip = &pos[1]; | 269 | pos->ip = &pos[1]; |
270 | memcpy (&pos[1], ip, ip_len); | 270 | GNUNET_memcpy (&pos[1], ip, ip_len); |
271 | pos->last_request = now; | 271 | pos->last_request = now; |
272 | pos->last_refresh = now; | 272 | pos->last_refresh = now; |
273 | pos->ip_len = ip_len; | 273 | pos->ip_len = ip_len; |
diff --git a/src/util/helper.c b/src/util/helper.c index ecfe4ccfa..cdb1b01d4 100644 --- a/src/util/helper.c +++ b/src/util/helper.c | |||
@@ -669,7 +669,7 @@ GNUNET_HELPER_send (struct GNUNET_HELPER_Handle *h, | |||
669 | mlen = ntohs (msg->size); | 669 | mlen = ntohs (msg->size); |
670 | sh = GNUNET_malloc (sizeof (struct GNUNET_HELPER_SendHandle) + mlen); | 670 | sh = GNUNET_malloc (sizeof (struct GNUNET_HELPER_SendHandle) + mlen); |
671 | sh->msg = (const struct GNUNET_MessageHeader*) &sh[1]; | 671 | sh->msg = (const struct GNUNET_MessageHeader*) &sh[1]; |
672 | memcpy (&sh[1], msg, mlen); | 672 | GNUNET_memcpy (&sh[1], msg, mlen); |
673 | sh->h = h; | 673 | sh->h = h; |
674 | sh->cont = cont; | 674 | sh->cont = cont; |
675 | sh->cont_cls = cont_cls; | 675 | sh->cont_cls = cont_cls; |
diff --git a/src/util/mq.c b/src/util/mq.c index 59a5f177a..9709fb6c8 100644 --- a/src/util/mq.c +++ b/src/util/mq.c | |||
@@ -362,7 +362,7 @@ GNUNET_MQ_send_copy (struct GNUNET_MQ_Handle *mq, | |||
362 | env->mh = (struct GNUNET_MessageHeader *) &env[1]; | 362 | env->mh = (struct GNUNET_MessageHeader *) &env[1]; |
363 | env->sent_cb = ev->sent_cb; | 363 | env->sent_cb = ev->sent_cb; |
364 | env->sent_cls = ev->sent_cls; | 364 | env->sent_cls = ev->sent_cls; |
365 | memcpy (&env[1], | 365 | GNUNET_memcpy (&env[1], |
366 | ev->mh, | 366 | ev->mh, |
367 | msize); | 367 | msize); |
368 | GNUNET_MQ_send (mq, | 368 | GNUNET_MQ_send (mq, |
@@ -460,7 +460,7 @@ GNUNET_MQ_queue_for_callbacks (GNUNET_MQ_SendImpl send, | |||
460 | for (i=0;NULL != handlers[i].cb; i++) ; | 460 | for (i=0;NULL != handlers[i].cb; i++) ; |
461 | mq->handlers = GNUNET_new_array (i + 1, | 461 | mq->handlers = GNUNET_new_array (i + 1, |
462 | struct GNUNET_MQ_MessageHandler); | 462 | struct GNUNET_MQ_MessageHandler); |
463 | memcpy (mq->handlers, | 463 | GNUNET_memcpy (mq->handlers, |
464 | handlers, | 464 | handlers, |
465 | i * sizeof (struct GNUNET_MQ_MessageHandler)); | 465 | i * sizeof (struct GNUNET_MQ_MessageHandler)); |
466 | } | 466 | } |
@@ -564,7 +564,7 @@ GNUNET_MQ_msg_copy (const struct GNUNET_MessageHeader *hdr) | |||
564 | 564 | ||
565 | mqm = GNUNET_malloc (sizeof (*mqm) + size); | 565 | mqm = GNUNET_malloc (sizeof (*mqm) + size); |
566 | mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1]; | 566 | mqm->mh = (struct GNUNET_MessageHeader *) &mqm[1]; |
567 | memcpy (mqm->mh, | 567 | GNUNET_memcpy (mqm->mh, |
568 | hdr, | 568 | hdr, |
569 | size); | 569 | size); |
570 | return mqm; | 570 | return mqm; |
@@ -599,7 +599,7 @@ GNUNET_MQ_msg_nested_mh_ (struct GNUNET_MessageHeader **mhp, | |||
599 | return NULL; | 599 | return NULL; |
600 | 600 | ||
601 | mqm = GNUNET_MQ_msg_ (mhp, size, type); | 601 | mqm = GNUNET_MQ_msg_ (mhp, size, type); |
602 | memcpy ((char *) mqm->mh + base_size, | 602 | GNUNET_memcpy ((char *) mqm->mh + base_size, |
603 | nested_mh, | 603 | nested_mh, |
604 | ntohs (nested_mh->size)); | 604 | ntohs (nested_mh->size)); |
605 | 605 | ||
@@ -628,7 +628,7 @@ transmit_queued (void *cls, | |||
628 | GNUNET_assert (NULL != buf); | 628 | GNUNET_assert (NULL != buf); |
629 | msg_size = ntohs (msg->size); | 629 | msg_size = ntohs (msg->size); |
630 | GNUNET_assert (size >= msg_size); | 630 | GNUNET_assert (size >= msg_size); |
631 | memcpy (buf, msg, msg_size); | 631 | GNUNET_memcpy (buf, msg, msg_size); |
632 | state->th = NULL; | 632 | state->th = NULL; |
633 | 633 | ||
634 | GNUNET_MQ_impl_send_continue (mq); | 634 | GNUNET_MQ_impl_send_continue (mq); |
@@ -756,7 +756,7 @@ connection_client_transmit_queued (void *cls, | |||
756 | 756 | ||
757 | msg_size = ntohs (msg->size); | 757 | msg_size = ntohs (msg->size); |
758 | GNUNET_assert (size >= msg_size); | 758 | GNUNET_assert (size >= msg_size); |
759 | memcpy (buf, msg, msg_size); | 759 | GNUNET_memcpy (buf, msg, msg_size); |
760 | state->th = NULL; | 760 | state->th = NULL; |
761 | 761 | ||
762 | GNUNET_MQ_impl_send_continue (mq); | 762 | GNUNET_MQ_impl_send_continue (mq); |
@@ -829,7 +829,7 @@ GNUNET_MQ_queue_for_connection_client (struct GNUNET_CLIENT_Connection *connecti | |||
829 | for (i=0;NULL != handlers[i].cb; i++) ; | 829 | for (i=0;NULL != handlers[i].cb; i++) ; |
830 | mq->handlers = GNUNET_new_array (i, | 830 | mq->handlers = GNUNET_new_array (i, |
831 | struct GNUNET_MQ_MessageHandler); | 831 | struct GNUNET_MQ_MessageHandler); |
832 | memcpy (mq->handlers, | 832 | GNUNET_memcpy (mq->handlers, |
833 | handlers, | 833 | handlers, |
834 | i * sizeof (struct GNUNET_MQ_MessageHandler)); | 834 | i * sizeof (struct GNUNET_MQ_MessageHandler)); |
835 | } | 835 | } |
diff --git a/src/util/network.c b/src/util/network.c index ba213b412..7f02395c6 100644 --- a/src/util/network.c +++ b/src/util/network.c | |||
@@ -201,7 +201,7 @@ GNUNET_NETWORK_unix_precheck (const struct sockaddr_un *un) | |||
201 | 201 | ||
202 | 202 | ||
203 | #ifndef FD_COPY | 203 | #ifndef FD_COPY |
204 | #define FD_COPY(s, d) (memcpy ((d), (s), sizeof (fd_set))) | 204 | #define FD_COPY(s, d) do { GNUNET_memcpy ((d), (s), sizeof (fd_set)); } while (0) |
205 | #endif | 205 | #endif |
206 | 206 | ||
207 | 207 | ||
@@ -546,7 +546,7 @@ GNUNET_NETWORK_socket_bind (struct GNUNET_NETWORK_Handle *desc, | |||
546 | return GNUNET_SYSERR; | 546 | return GNUNET_SYSERR; |
547 | #ifndef MINGW | 547 | #ifndef MINGW |
548 | desc->addr = GNUNET_malloc (address_len); | 548 | desc->addr = GNUNET_malloc (address_len); |
549 | memcpy (desc->addr, address, address_len); | 549 | GNUNET_memcpy (desc->addr, address, address_len); |
550 | desc->addrlen = address_len; | 550 | desc->addrlen = address_len; |
551 | #endif | 551 | #endif |
552 | return GNUNET_OK; | 552 | return GNUNET_OK; |
@@ -1210,7 +1210,7 @@ GNUNET_NETWORK_fdset_copy (struct GNUNET_NETWORK_FDSet *to, | |||
1210 | GNUNET_array_grow (to->handles, | 1210 | GNUNET_array_grow (to->handles, |
1211 | to->handles_size, | 1211 | to->handles_size, |
1212 | from->handles_pos * 2); | 1212 | from->handles_pos * 2); |
1213 | memcpy (to->handles, | 1213 | GNUNET_memcpy (to->handles, |
1214 | from->handles, | 1214 | from->handles, |
1215 | from->handles_pos * sizeof (struct GNUNET_NETWORK_Handle *)); | 1215 | from->handles_pos * sizeof (struct GNUNET_NETWORK_Handle *)); |
1216 | to->handles_pos = from->handles_pos; | 1216 | to->handles_pos = from->handles_pos; |
diff --git a/src/util/os_installation.c b/src/util/os_installation.c index a0e8647a1..ea3ae3e79 100644 --- a/src/util/os_installation.c +++ b/src/util/os_installation.c | |||
@@ -289,7 +289,7 @@ get_path_from_module_filename () | |||
289 | GNUNET_assert (0); | 289 | GNUNET_assert (0); |
290 | 290 | ||
291 | upath = GNUNET_malloc (u8_string_length + 1); | 291 | upath = GNUNET_malloc (u8_string_length + 1); |
292 | memcpy (upath, u8_string, u8_string_length); | 292 | GNUNET_memcpy (upath, u8_string, u8_string_length); |
293 | upath[u8_string_length] = '\0'; | 293 | upath[u8_string_length] = '\0'; |
294 | 294 | ||
295 | free (u8_string); | 295 | free (u8_string); |
diff --git a/src/util/program.c b/src/util/program.c index 72f6a1e6c..d0dd49909 100644 --- a/src/util/program.c +++ b/src/util/program.c | |||
@@ -204,8 +204,8 @@ GNUNET_PROGRAM_run2 (int argc, char *const *argv, const char *binaryName, | |||
204 | GNUNET_malloc ((cnt + | 204 | GNUNET_malloc ((cnt + |
205 | 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) + | 205 | 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption) + |
206 | sizeof (defoptions)); | 206 | sizeof (defoptions)); |
207 | memcpy (allopts, defoptions, sizeof (defoptions)); | 207 | GNUNET_memcpy (allopts, defoptions, sizeof (defoptions)); |
208 | memcpy (&allopts | 208 | GNUNET_memcpy (&allopts |
209 | [sizeof (defoptions) / | 209 | [sizeof (defoptions) / |
210 | sizeof (struct GNUNET_GETOPT_CommandLineOption)], options, | 210 | sizeof (struct GNUNET_GETOPT_CommandLineOption)], options, |
211 | (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption)); | 211 | (cnt + 1) * sizeof (struct GNUNET_GETOPT_CommandLineOption)); |
diff --git a/src/util/resolver_api.c b/src/util/resolver_api.c index b41382683..299fdfef9 100644 --- a/src/util/resolver_api.c +++ b/src/util/resolver_api.c | |||
@@ -387,7 +387,7 @@ process_requests () | |||
387 | GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST); | 387 | GNUNET_MESSAGE_TYPE_RESOLVER_REQUEST); |
388 | msg->direction = htonl (rh->direction); | 388 | msg->direction = htonl (rh->direction); |
389 | msg->af = htonl (rh->af); | 389 | msg->af = htonl (rh->af); |
390 | memcpy (&msg[1], | 390 | GNUNET_memcpy (&msg[1], |
391 | &rh[1], | 391 | &rh[1], |
392 | rh->data_len); | 392 | rh->data_len); |
393 | LOG (GNUNET_ERROR_TYPE_DEBUG, | 393 | LOG (GNUNET_ERROR_TYPE_DEBUG, |
@@ -845,7 +845,7 @@ GNUNET_RESOLVER_ip_get (const char *hostname, | |||
845 | rh->af = af; | 845 | rh->af = af; |
846 | rh->addr_callback = callback; | 846 | rh->addr_callback = callback; |
847 | rh->cls = callback_cls; | 847 | rh->cls = callback_cls; |
848 | memcpy (&rh[1], | 848 | GNUNET_memcpy (&rh[1], |
849 | hostname, | 849 | hostname, |
850 | slen); | 850 | slen); |
851 | rh->data_len = slen; | 851 | rh->data_len = slen; |
@@ -983,7 +983,7 @@ GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, | |||
983 | rh->cls = cls; | 983 | rh->cls = cls; |
984 | rh->af = sa->sa_family; | 984 | rh->af = sa->sa_family; |
985 | rh->timeout = GNUNET_TIME_relative_to_absolute (timeout); | 985 | rh->timeout = GNUNET_TIME_relative_to_absolute (timeout); |
986 | memcpy (&rh[1], | 986 | GNUNET_memcpy (&rh[1], |
987 | ip, | 987 | ip, |
988 | ip_len); | 988 | ip_len); |
989 | rh->data_len = ip_len; | 989 | rh->data_len = ip_len; |
diff --git a/src/util/server_mst.c b/src/util/server_mst.c index 0a686a079..41b2e8ed9 100644 --- a/src/util/server_mst.c +++ b/src/util/server_mst.c | |||
@@ -152,7 +152,7 @@ do_align: | |||
152 | delta = | 152 | delta = |
153 | GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) - | 153 | GNUNET_MIN (sizeof (struct GNUNET_MessageHeader) - |
154 | (mst->pos - mst->off), size); | 154 | (mst->pos - mst->off), size); |
155 | memcpy (&ibuf[mst->pos], buf, delta); | 155 | GNUNET_memcpy (&ibuf[mst->pos], buf, delta); |
156 | mst->pos += delta; | 156 | mst->pos += delta; |
157 | buf += delta; | 157 | buf += delta; |
158 | size -= delta; | 158 | size -= delta; |
@@ -194,7 +194,7 @@ do_align: | |||
194 | { | 194 | { |
195 | delta = GNUNET_MIN (want - (mst->pos - mst->off), size); | 195 | delta = GNUNET_MIN (want - (mst->pos - mst->off), size); |
196 | GNUNET_assert (mst->pos + delta <= mst->curr_buf); | 196 | GNUNET_assert (mst->pos + delta <= mst->curr_buf); |
197 | memcpy (&ibuf[mst->pos], buf, delta); | 197 | GNUNET_memcpy (&ibuf[mst->pos], buf, delta); |
198 | mst->pos += delta; | 198 | mst->pos += delta; |
199 | buf += delta; | 199 | buf += delta; |
200 | size -= delta; | 200 | size -= delta; |
@@ -281,7 +281,7 @@ copy: | |||
281 | mst->curr_buf = size + mst->pos; | 281 | mst->curr_buf = size + mst->pos; |
282 | } | 282 | } |
283 | GNUNET_assert (size + mst->pos <= mst->curr_buf); | 283 | GNUNET_assert (size + mst->pos <= mst->curr_buf); |
284 | memcpy (&ibuf[mst->pos], buf, size); | 284 | GNUNET_memcpy (&ibuf[mst->pos], buf, size); |
285 | mst->pos += size; | 285 | mst->pos += size; |
286 | } | 286 | } |
287 | if (purge) | 287 | if (purge) |
diff --git a/src/util/server_nc.c b/src/util/server_nc.c index 75c9e1bc2..a95cd7f6d 100644 --- a/src/util/server_nc.c +++ b/src/util/server_nc.c | |||
@@ -326,7 +326,7 @@ transmit_message (void *cls, | |||
326 | "Copying message of type %u and size %u from pending queue to transmission buffer\n", | 326 | "Copying message of type %u and size %u from pending queue to transmission buffer\n", |
327 | ntohs (pml->msg->type), | 327 | ntohs (pml->msg->type), |
328 | msize); | 328 | msize); |
329 | memcpy (&cbuf[ret], pml->msg, msize); | 329 | GNUNET_memcpy (&cbuf[ret], pml->msg, msize); |
330 | ret += msize; | 330 | ret += msize; |
331 | size -= msize; | 331 | size -= msize; |
332 | GNUNET_free (pml); | 332 | GNUNET_free (pml); |
@@ -391,7 +391,7 @@ do_unicast (struct GNUNET_SERVER_NotificationContext *nc, | |||
391 | ntohs (msg->type), | 391 | ntohs (msg->type), |
392 | ntohs (msg->size), | 392 | ntohs (msg->size), |
393 | (unsigned int) nc->queue_length); | 393 | (unsigned int) nc->queue_length); |
394 | memcpy (&pml[1], msg, size); | 394 | GNUNET_memcpy (&pml[1], msg, size); |
395 | /* append */ | 395 | /* append */ |
396 | GNUNET_CONTAINER_DLL_insert_tail (client->pending_head, | 396 | GNUNET_CONTAINER_DLL_insert_tail (client->pending_head, |
397 | client->pending_tail, | 397 | client->pending_tail, |
diff --git a/src/util/server_tc.c b/src/util/server_tc.c index 986bc9b43..40a8ba015 100644 --- a/src/util/server_tc.c +++ b/src/util/server_tc.c | |||
@@ -87,7 +87,7 @@ transmit_response (void *cls, size_t size, void *buf) | |||
87 | msize = size; | 87 | msize = size; |
88 | else | 88 | else |
89 | msize = tc->total - tc->off; | 89 | msize = tc->total - tc->off; |
90 | memcpy (buf, &tc->buf[tc->off], msize); | 90 | GNUNET_memcpy (buf, &tc->buf[tc->off], msize); |
91 | tc->off += msize; | 91 | tc->off += msize; |
92 | if (tc->total == tc->off) | 92 | if (tc->total == tc->off) |
93 | { | 93 | { |
@@ -160,7 +160,7 @@ GNUNET_SERVER_transmit_context_append_data (struct GNUNET_SERVER_TransmitContext | |||
160 | tc->total += size; | 160 | tc->total += size; |
161 | msg->size = htons (size); | 161 | msg->size = htons (size); |
162 | msg->type = htons (type); | 162 | msg->type = htons (type); |
163 | memcpy (&msg[1], data, length); | 163 | GNUNET_memcpy (&msg[1], data, length); |
164 | } | 164 | } |
165 | 165 | ||
166 | 166 | ||
@@ -186,7 +186,7 @@ GNUNET_SERVER_transmit_context_append_message (struct | |||
186 | tc->buf = GNUNET_realloc (tc->buf, tc->total + size); | 186 | tc->buf = GNUNET_realloc (tc->buf, tc->total + size); |
187 | m = (struct GNUNET_MessageHeader *) &tc->buf[tc->total]; | 187 | m = (struct GNUNET_MessageHeader *) &tc->buf[tc->total]; |
188 | tc->total += size; | 188 | tc->total += size; |
189 | memcpy (m, msg, size); | 189 | GNUNET_memcpy (m, msg, size); |
190 | } | 190 | } |
191 | 191 | ||
192 | 192 | ||
diff --git a/src/util/service.c b/src/util/service.c index bdef17361..3beb4a085 100644 --- a/src/util/service.c +++ b/src/util/service.c | |||
@@ -756,7 +756,7 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name, | |||
756 | GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen); | 756 | GNUNET_assert (sizeof (struct sockaddr_in) == pos->ai_addrlen); |
757 | saddrlens[i] = pos->ai_addrlen; | 757 | saddrlens[i] = pos->ai_addrlen; |
758 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | 758 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
759 | memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | 759 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); |
760 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); | 760 | ((struct sockaddr_in *) saddrs[i])->sin_port = htons (port); |
761 | } | 761 | } |
762 | else | 762 | else |
@@ -765,7 +765,7 @@ GNUNET_SERVICE_get_server_addresses (const char *service_name, | |||
765 | GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen); | 765 | GNUNET_assert (sizeof (struct sockaddr_in6) == pos->ai_addrlen); |
766 | saddrlens[i] = pos->ai_addrlen; | 766 | saddrlens[i] = pos->ai_addrlen; |
767 | saddrs[i] = GNUNET_malloc (saddrlens[i]); | 767 | saddrs[i] = GNUNET_malloc (saddrlens[i]); |
768 | memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); | 768 | GNUNET_memcpy (saddrs[i], pos->ai_addr, saddrlens[i]); |
769 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); | 769 | ((struct sockaddr_in6 *) saddrs[i])->sin6_port = htons (port); |
770 | } | 770 | } |
771 | i++; | 771 | i++; |
@@ -1191,7 +1191,7 @@ service_task (void *cls) | |||
1191 | sctx); | 1191 | sctx); |
1192 | } | 1192 | } |
1193 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); | 1193 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); |
1194 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); | 1194 | GNUNET_memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); |
1195 | i = 0; | 1195 | i = 0; |
1196 | while (NULL != sctx->my_handlers[i].callback) | 1196 | while (NULL != sctx->my_handlers[i].callback) |
1197 | sctx->my_handlers[i++].callback_cls = sctx; | 1197 | sctx->my_handlers[i++].callback_cls = sctx; |
@@ -1603,7 +1603,7 @@ GNUNET_SERVICE_start (const char *service_name, | |||
1603 | sctx->match_gid); | 1603 | sctx->match_gid); |
1604 | #endif | 1604 | #endif |
1605 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); | 1605 | sctx->my_handlers = GNUNET_malloc (sizeof (defhandlers)); |
1606 | memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); | 1606 | GNUNET_memcpy (sctx->my_handlers, defhandlers, sizeof (defhandlers)); |
1607 | i = 0; | 1607 | i = 0; |
1608 | while ((sctx->my_handlers[i].callback != NULL)) | 1608 | while ((sctx->my_handlers[i].callback != NULL)) |
1609 | sctx->my_handlers[i++].callback_cls = sctx; | 1609 | sctx->my_handlers[i++].callback_cls = sctx; |
diff --git a/src/util/socks.c b/src/util/socks.c index bda8765ad..1525b3c75 100644 --- a/src/util/socks.c +++ b/src/util/socks.c | |||
@@ -296,7 +296,7 @@ reciever (void *cls, | |||
296 | { | 296 | { |
297 | struct GNUNET_SOCKS_Handshake * ih = cls; | 297 | struct GNUNET_SOCKS_Handshake * ih = cls; |
298 | GNUNET_assert (&ih->inend[available] < &ih->inbuf[1024]); | 298 | GNUNET_assert (&ih->inend[available] < &ih->inbuf[1024]); |
299 | memcpy(ih->inend, buf, available); | 299 | GNUNET_memcpy(ih->inend, buf, available); |
300 | ih->inend += available; | 300 | ih->inend += available; |
301 | SOCKS5_handshake_step (ih); | 301 | SOCKS5_handshake_step (ih); |
302 | } | 302 | } |
@@ -375,7 +375,7 @@ transmit_ready (void *cls, | |||
375 | GNUNET_assert (e <= &ih->outbuf[1024]); | 375 | GNUNET_assert (e <= &ih->outbuf[1024]); |
376 | unsigned l = e - b; | 376 | unsigned l = e - b; |
377 | GNUNET_assert (size >= l && l >= 0); | 377 | GNUNET_assert (size >= l && l >= 0); |
378 | memcpy(buf, b, l); | 378 | GNUNET_memcpy(buf, b, l); |
379 | register_reciever (ih, register_reciever_wants(ih)); | 379 | register_reciever (ih, register_reciever_wants(ih)); |
380 | return l; | 380 | return l; |
381 | } | 381 | } |
@@ -497,11 +497,11 @@ GNUNET_SOCKS_set_handshake_destination (struct GNUNET_SOCKS_Handshake *ih, | |||
497 | /* Specify destination */ | 497 | /* Specify destination */ |
498 | if (1 == inet_pton(AF_INET,host,&ia.in4)) { | 498 | if (1 == inet_pton(AF_INET,host,&ia.in4)) { |
499 | *(b++)= 1; /* IPv4 */ | 499 | *(b++)= 1; /* IPv4 */ |
500 | memcpy (b, &ia.in4, sizeof(struct in_addr)); | 500 | GNUNET_memcpy (b, &ia.in4, sizeof(struct in_addr)); |
501 | b += sizeof(struct in_addr); /* 4 */ | 501 | b += sizeof(struct in_addr); /* 4 */ |
502 | } else if (1 == inet_pton(AF_INET6,host,&ia.in6)) { | 502 | } else if (1 == inet_pton(AF_INET6,host,&ia.in6)) { |
503 | *(b++)= 4; /* IPv6 */ | 503 | *(b++)= 4; /* IPv6 */ |
504 | memcpy (b, &ia.in6, sizeof(struct in6_addr)); | 504 | GNUNET_memcpy (b, &ia.in6, sizeof(struct in6_addr)); |
505 | b += sizeof(struct in6_addr); /* 16 */ | 505 | b += sizeof(struct in6_addr); /* 16 */ |
506 | } else { | 506 | } else { |
507 | *(b++)= 3; /* hostname */ | 507 | *(b++)= 3; /* hostname */ |
diff --git a/src/util/strings.c b/src/util/strings.c index 06d05f2ef..abaaf23b2 100644 --- a/src/util/strings.c +++ b/src/util/strings.c | |||
@@ -79,7 +79,7 @@ GNUNET_STRINGS_buffer_fill (char *buffer, size_t size, unsigned int count, ...) | |||
79 | if (buffer != NULL) | 79 | if (buffer != NULL) |
80 | { | 80 | { |
81 | GNUNET_assert (needed + slen <= size); | 81 | GNUNET_assert (needed + slen <= size); |
82 | memcpy (&buffer[needed], s, slen); | 82 | GNUNET_memcpy (&buffer[needed], s, slen); |
83 | } | 83 | } |
84 | needed += slen; | 84 | needed += slen; |
85 | count--; | 85 | count--; |
@@ -412,7 +412,7 @@ GNUNET_STRINGS_conv (const char *input, | |||
412 | if (0 == strcmp (output_charset, "UTF-8")) | 412 | if (0 == strcmp (output_charset, "UTF-8")) |
413 | { | 413 | { |
414 | ret = GNUNET_malloc (u8_string_length + 1); | 414 | ret = GNUNET_malloc (u8_string_length + 1); |
415 | memcpy (ret, u8_string, u8_string_length); | 415 | GNUNET_memcpy (ret, u8_string, u8_string_length); |
416 | ret[u8_string_length] = '\0'; | 416 | ret[u8_string_length] = '\0'; |
417 | free (u8_string); | 417 | free (u8_string); |
418 | return ret; | 418 | return ret; |
@@ -428,7 +428,7 @@ GNUNET_STRINGS_conv (const char *input, | |||
428 | goto fail; | 428 | goto fail; |
429 | } | 429 | } |
430 | ret = GNUNET_malloc (encoded_string_length + 1); | 430 | ret = GNUNET_malloc (encoded_string_length + 1); |
431 | memcpy (ret, encoded_string, encoded_string_length); | 431 | GNUNET_memcpy (ret, encoded_string, encoded_string_length); |
432 | ret[encoded_string_length] = '\0'; | 432 | ret[encoded_string_length] = '\0'; |
433 | free (encoded_string); | 433 | free (encoded_string); |
434 | return ret; | 434 | return ret; |
@@ -437,7 +437,7 @@ GNUNET_STRINGS_conv (const char *input, | |||
437 | _("Character sets requested were `%s'->`%s'\n"), | 437 | _("Character sets requested were `%s'->`%s'\n"), |
438 | "UTF-8", output_charset); | 438 | "UTF-8", output_charset); |
439 | ret = GNUNET_malloc (len + 1); | 439 | ret = GNUNET_malloc (len + 1); |
440 | memcpy (ret, input, len); | 440 | GNUNET_memcpy (ret, input, len); |
441 | ret[len] = '\0'; | 441 | ret[len] = '\0'; |
442 | return ret; | 442 | return ret; |
443 | } | 443 | } |
@@ -500,7 +500,7 @@ GNUNET_STRINGS_utf8_tolower (const char *input, | |||
500 | 500 | ||
501 | tmp_in = u8_tolower ((uint8_t*)input, strlen ((char *) input), | 501 | tmp_in = u8_tolower ((uint8_t*)input, strlen ((char *) input), |
502 | NULL, UNINORM_NFD, NULL, &len); | 502 | NULL, UNINORM_NFD, NULL, &len); |
503 | memcpy(output, tmp_in, len); | 503 | GNUNET_memcpy(output, tmp_in, len); |
504 | output[len] = '\0'; | 504 | output[len] = '\0'; |
505 | free(tmp_in); | 505 | free(tmp_in); |
506 | } | 506 | } |
@@ -522,7 +522,7 @@ GNUNET_STRINGS_utf8_toupper(const char *input, | |||
522 | 522 | ||
523 | tmp_in = u8_toupper ((uint8_t*)input, strlen ((char *) input), | 523 | tmp_in = u8_toupper ((uint8_t*)input, strlen ((char *) input), |
524 | NULL, UNINORM_NFD, NULL, &len); | 524 | NULL, UNINORM_NFD, NULL, &len); |
525 | memcpy (output, tmp_in, len); | 525 | GNUNET_memcpy (output, tmp_in, len); |
526 | output[len] = '\0'; | 526 | output[len] = '\0'; |
527 | free (tmp_in); | 527 | free (tmp_in); |
528 | } | 528 | } |
@@ -1073,7 +1073,7 @@ GNUNET_STRINGS_parse_uri (const char *path, char **scheme_part, | |||
1073 | if (scheme_part) | 1073 | if (scheme_part) |
1074 | { | 1074 | { |
1075 | *scheme_part = GNUNET_malloc (post_scheme_part - path + 1); | 1075 | *scheme_part = GNUNET_malloc (post_scheme_part - path + 1); |
1076 | memcpy (*scheme_part, path, post_scheme_part - path); | 1076 | GNUNET_memcpy (*scheme_part, path, post_scheme_part - path); |
1077 | (*scheme_part)[post_scheme_part - path] = '\0'; | 1077 | (*scheme_part)[post_scheme_part - path] = '\0'; |
1078 | } | 1078 | } |
1079 | if (path_part) | 1079 | if (path_part) |
@@ -1222,7 +1222,7 @@ GNUNET_STRINGS_to_address_ipv6 (const char *zt_addr, | |||
1222 | 1222 | ||
1223 | if (addrlen < 6) | 1223 | if (addrlen < 6) |
1224 | return GNUNET_SYSERR; | 1224 | return GNUNET_SYSERR; |
1225 | memcpy (zbuf, zt_addr, addrlen); | 1225 | GNUNET_memcpy (zbuf, zt_addr, addrlen); |
1226 | if ('[' != zbuf[0]) | 1226 | if ('[' != zbuf[0]) |
1227 | { | 1227 | { |
1228 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, | 1228 | GNUNET_log (GNUNET_ERROR_TYPE_WARNING, |
diff --git a/src/util/test_client.c b/src/util/test_client.c index 89adf41a3..07af5ea35 100644 --- a/src/util/test_client.c +++ b/src/util/test_client.c | |||
@@ -52,7 +52,7 @@ copy_msg (void *cls, size_t size, void *buf) | |||
52 | 52 | ||
53 | GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size)); | 53 | GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size)); |
54 | GNUNET_assert (size >= ntohs (cpy->size)); | 54 | GNUNET_assert (size >= ntohs (cpy->size)); |
55 | memcpy (buf, cpy, ntohs (cpy->size)); | 55 | GNUNET_memcpy (buf, cpy, ntohs (cpy->size)); |
56 | GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK); | 56 | GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK); |
57 | GNUNET_free (cpy); | 57 | GNUNET_free (cpy); |
58 | GNUNET_free (ctx); | 58 | GNUNET_free (ctx); |
@@ -79,7 +79,7 @@ echo_cb (void *cls, | |||
79 | cc = GNUNET_new (struct CopyContext); | 79 | cc = GNUNET_new (struct CopyContext); |
80 | cc->client = client; | 80 | cc->client = client; |
81 | cpy = GNUNET_malloc (ntohs (message->size)); | 81 | cpy = GNUNET_malloc (ntohs (message->size)); |
82 | memcpy (cpy, message, ntohs (message->size)); | 82 | GNUNET_memcpy (cpy, message, ntohs (message->size)); |
83 | cc->cpy = cpy; | 83 | cc->cpy = cpy; |
84 | GNUNET_assert (NULL != | 84 | GNUNET_assert (NULL != |
85 | GNUNET_SERVER_notify_transmit_ready (client, | 85 | GNUNET_SERVER_notify_transmit_ready (client, |
diff --git a/src/util/test_crypto_symmetric.c b/src/util/test_crypto_symmetric.c index b01b66e93..b2fdd07c3 100644 --- a/src/util/test_crypto_symmetric.c +++ b/src/util/test_crypto_symmetric.c | |||
@@ -103,8 +103,8 @@ verifyCrypto () | |||
103 | res = NULL; | 103 | res = NULL; |
104 | ret = 0; | 104 | ret = 0; |
105 | 105 | ||
106 | memcpy (key.aes_key, raw_key_aes, GNUNET_CRYPTO_AES_KEY_LENGTH); | 106 | GNUNET_memcpy (key.aes_key, raw_key_aes, GNUNET_CRYPTO_AES_KEY_LENGTH); |
107 | memcpy (key.twofish_key, raw_key_twofish, GNUNET_CRYPTO_AES_KEY_LENGTH); | 107 | GNUNET_memcpy (key.twofish_key, raw_key_twofish, GNUNET_CRYPTO_AES_KEY_LENGTH); |
108 | if (GNUNET_CRYPTO_AES_KEY_LENGTH != | 108 | if (GNUNET_CRYPTO_AES_KEY_LENGTH != |
109 | GNUNET_CRYPTO_symmetric_encrypt (plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key, | 109 | GNUNET_CRYPTO_symmetric_encrypt (plain, GNUNET_CRYPTO_AES_KEY_LENGTH, &key, |
110 | (const struct | 110 | (const struct |
diff --git a/src/util/test_server.c b/src/util/test_server.c index 384a1cef0..6d8fffc69 100644 --- a/src/util/test_server.c +++ b/src/util/test_server.c | |||
@@ -151,7 +151,7 @@ reply_msg (void *cls, | |||
151 | GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader)); | 151 | GNUNET_assert (size >= sizeof (struct GNUNET_MessageHeader)); |
152 | msg.type = htons (MY_TYPE); | 152 | msg.type = htons (MY_TYPE); |
153 | msg.size = htons (sizeof (struct GNUNET_MessageHeader)); | 153 | msg.size = htons (sizeof (struct GNUNET_MessageHeader)); |
154 | memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader)); | 154 | GNUNET_memcpy (buf, &msg, sizeof (struct GNUNET_MessageHeader)); |
155 | GNUNET_assert (NULL != argclient); | 155 | GNUNET_assert (NULL != argclient); |
156 | GNUNET_SERVER_receive_done (argclient, GNUNET_OK); | 156 | GNUNET_SERVER_receive_done (argclient, GNUNET_OK); |
157 | GNUNET_SERVER_client_drop (argclient); | 157 | GNUNET_SERVER_client_drop (argclient); |
diff --git a/src/util/test_socks.c b/src/util/test_socks.c index 4b86d25dc..d6064afd5 100644 --- a/src/util/test_socks.c +++ b/src/util/test_socks.c | |||
@@ -51,7 +51,7 @@ copy_msg (void *cls, size_t size, void *buf) | |||
51 | 51 | ||
52 | GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size)); | 52 | GNUNET_assert (sizeof (struct GNUNET_MessageHeader) == ntohs (cpy->size)); |
53 | GNUNET_assert (size >= ntohs (cpy->size)); | 53 | GNUNET_assert (size >= ntohs (cpy->size)); |
54 | memcpy (buf, cpy, ntohs (cpy->size)); | 54 | GNUNET_memcpy (buf, cpy, ntohs (cpy->size)); |
55 | GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK); | 55 | GNUNET_SERVER_receive_done (ctx->client, GNUNET_OK); |
56 | GNUNET_free (cpy); | 56 | GNUNET_free (cpy); |
57 | GNUNET_free (ctx); | 57 | GNUNET_free (ctx); |
@@ -76,7 +76,7 @@ echo_cb (void *cls, struct GNUNET_SERVER_Client *client, | |||
76 | cc = GNUNET_new (struct CopyContext); | 76 | cc = GNUNET_new (struct CopyContext); |
77 | cc->client = client; | 77 | cc->client = client; |
78 | cpy = GNUNET_malloc (ntohs (message->size)); | 78 | cpy = GNUNET_malloc (ntohs (message->size)); |
79 | memcpy (cpy, message, ntohs (message->size)); | 79 | GNUNET_memcpy (cpy, message, ntohs (message->size)); |
80 | cc->cpy = cpy; | 80 | cc->cpy = cpy; |
81 | GNUNET_assert (NULL != | 81 | GNUNET_assert (NULL != |
82 | GNUNET_SERVER_notify_transmit_ready (client, | 82 | GNUNET_SERVER_notify_transmit_ready (client, |
diff --git a/src/util/win.c b/src/util/win.c index 88543de7b..7cd7e0f3c 100644 --- a/src/util/win.c +++ b/src/util/win.c | |||
@@ -500,7 +500,7 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count) | |||
500 | 500 | ||
501 | if (!use_enum2) | 501 | if (!use_enum2) |
502 | { | 502 | { |
503 | memcpy (&r->address, unicast->Address.lpSockaddr, | 503 | GNUNET_memcpy (&r->address, unicast->Address.lpSockaddr, |
504 | unicast->Address.iSockaddrLength); | 504 | unicast->Address.iSockaddrLength); |
505 | memset (&r->mask, 0, sizeof (struct sockaddr)); | 505 | memset (&r->mask, 0, sizeof (struct sockaddr)); |
506 | mask_length = ((IP_ADAPTER_UNICAST_ADDRESS_VISTA *) unicast)-> | 506 | mask_length = ((IP_ADAPTER_UNICAST_ADDRESS_VISTA *) unicast)-> |
@@ -520,7 +520,7 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count) | |||
520 | struct sockaddr_in6 *b = (struct sockaddr_in6 *) &r->broadcast; | 520 | struct sockaddr_in6 *b = (struct sockaddr_in6 *) &r->broadcast; |
521 | for (i = 0; i < mask_length; i++) | 521 | for (i = 0; i < mask_length; i++) |
522 | ((unsigned char *) &m->sin6_addr)[i / 8] |= 0x80 >> (i % 8); | 522 | ((unsigned char *) &m->sin6_addr)[i / 8] |= 0x80 >> (i % 8); |
523 | memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength); | 523 | GNUNET_memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength); |
524 | for (i = mask_length; i < 128; i++) | 524 | for (i = mask_length; i < 128; i++) |
525 | ((unsigned char *) &b->sin6_addr)[i / 8] |= 0x80 >> (i % 8); | 525 | ((unsigned char *) &b->sin6_addr)[i / 8] |= 0x80 >> (i % 8); |
526 | } | 526 | } |
@@ -534,14 +534,14 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count) | |||
534 | for (i = 0; !found && i < interfaces4_len / sizeof (INTERFACE_INFO); i++) | 534 | for (i = 0; !found && i < interfaces4_len / sizeof (INTERFACE_INFO); i++) |
535 | { | 535 | { |
536 | struct sockaddr_in *m = (struct sockaddr_in *) &r->mask; | 536 | struct sockaddr_in *m = (struct sockaddr_in *) &r->mask; |
537 | if (memcpy (&interfaces4[i].iiAddress.Address, | 537 | if (GNUNET_memcpy (&interfaces4[i].iiAddress.Address, |
538 | unicast->Address.lpSockaddr, | 538 | unicast->Address.lpSockaddr, |
539 | unicast->Address.iSockaddrLength) != 0) | 539 | unicast->Address.iSockaddrLength) != 0) |
540 | continue; | 540 | continue; |
541 | found = 1; | 541 | found = 1; |
542 | memcpy (&r->address, &interfaces4[i].iiAddress.Address, | 542 | GNUNET_memcpy (&r->address, &interfaces4[i].iiAddress.Address, |
543 | sizeof (struct sockaddr_in)); | 543 | sizeof (struct sockaddr_in)); |
544 | memcpy (&r->mask, &interfaces4[i].iiNetmask.Address, | 544 | GNUNET_memcpy (&r->mask, &interfaces4[i].iiNetmask.Address, |
545 | sizeof (struct sockaddr_in)); | 545 | sizeof (struct sockaddr_in)); |
546 | for (mask_length = 0; | 546 | for (mask_length = 0; |
547 | ((unsigned char *) &m->sin_addr)[mask_length / 8] & | 547 | ((unsigned char *) &m->sin_addr)[mask_length / 8] & |
@@ -557,12 +557,12 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count) | |||
557 | interfaces6 != NULL && !found && i < interfaces6->iAddressCount; | 557 | interfaces6 != NULL && !found && i < interfaces6->iAddressCount; |
558 | i++) | 558 | i++) |
559 | { | 559 | { |
560 | if (memcpy (interfaces6->Address[i].lpSockaddr, | 560 | if (GNUNET_memcpy (interfaces6->Address[i].lpSockaddr, |
561 | unicast->Address.lpSockaddr, | 561 | unicast->Address.lpSockaddr, |
562 | unicast->Address.iSockaddrLength) != 0) | 562 | unicast->Address.iSockaddrLength) != 0) |
563 | continue; | 563 | continue; |
564 | found = 1; | 564 | found = 1; |
565 | memcpy (&r->address, interfaces6->Address[i].lpSockaddr, | 565 | GNUNET_memcpy (&r->address, interfaces6->Address[i].lpSockaddr, |
566 | sizeof (struct sockaddr_in6)); | 566 | sizeof (struct sockaddr_in6)); |
567 | /* TODO: Find a way to reliably get network mask for IPv6 on XP */ | 567 | /* TODO: Find a way to reliably get network mask for IPv6 on XP */ |
568 | memset (&r->mask, 0, sizeof (struct sockaddr)); | 568 | memset (&r->mask, 0, sizeof (struct sockaddr)); |
@@ -582,7 +582,7 @@ EnumNICs3 (struct EnumNICs3_results **results, int *results_count) | |||
582 | * falling under netmask to 1, | 582 | * falling under netmask to 1, |
583 | * so we get, 192.168.0.255 from, say, 192.168.0.43 with mask == 24. | 583 | * so we get, 192.168.0.255 from, say, 192.168.0.43 with mask == 24. |
584 | */ | 584 | */ |
585 | memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength); | 585 | GNUNET_memcpy (&r->broadcast, &r->address, unicast->Address.iSockaddrLength); |
586 | for (i = mask_length; i < 32; i++) | 586 | for (i = mask_length; i < 32; i++) |
587 | ((unsigned char *) &m->sin_addr)[i / 8] |= 0x80 >> (i % 8); | 587 | ((unsigned char *) &m->sin_addr)[i / 8] |= 0x80 >> (i % 8); |
588 | r->flags |= ENUMNICS3_BCAST_OK; | 588 | r->flags |= ENUMNICS3_BCAST_OK; |