-avoid calling memcpy() with NULL argument, even if len is 0

4 files changed, 45 insertions, 45 deletions

diff --git a/src/social/gnunet-service-social.c b/src/social/gnunet-service-social.c
index 6c57fed31..287047f58 100644
--- a/src/social/gnunet-service-social.c
+++ b/src/social/gnunet-service-social.c
@@ -660,7 +660,7 @@ client_send_result (struct GNUNET_SERVER_Client *client, uint64_t op_id,
   res->result_code = GNUNET_htonll (result_code);
   res->op_id = op_id;
   if (0 < data_size)
-    memcpy (&res[1], data, data_size);
+    GNUNET_memcpy (&res[1], data, data_size);
 
   GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
               "%p Sending result to client for operation #%" PRIu64 ": "
@@ -1166,7 +1166,7 @@ app_place_add (const char *app_id,
 
   size_t app_id_size = strlen (app_id) + 1;
   void *app_id_value = GNUNET_malloc (app_id_size);
-  memcpy (app_id_value, app_id, app_id_size);
+  GNUNET_memcpy (app_id_value, app_id, app_id_size);
 
   if (GNUNET_OK != GNUNET_CONTAINER_multihashmap_put (place_apps, &app_id_hash, app_id_value,
                                                       GNUNET_CONTAINER_MULTIHASHMAPOPTION_UNIQUE_ONLY))
@@ -1630,7 +1630,7 @@ guest_enter (const struct GuestEnterRequest *greq, struct Guest **ret_gst)
     if (0 < relay_size)
     {
       gst->relays = GNUNET_malloc (relay_size);
-      memcpy (gst->relays, relays, relay_size);
+      GNUNET_memcpy (gst->relays, relays, relay_size);
     }
 
     gst->join_flags = ntohl (greq->flags);
@@ -1805,11 +1805,11 @@ gns_result_guest_enter (void *cls, uint32_t rd_count,
   greq->relay_count = rec->relay_count;
 
   void *p = &greq[1];
-  memcpy (p, gcls->app_id, app_id_size);
+  GNUNET_memcpy (p, gcls->app_id, app_id_size);
   p += app_id_size;
-  memcpy (p, relays, relay_size);
+  GNUNET_memcpy (p, relays, relay_size);
   p += relay_size;
-  memcpy (p, gcls->join_msg, join_msg_size);
+  GNUNET_memcpy (p, gcls->join_msg, join_msg_size);
 
   client_recv_guest_enter (NULL, gcls->client, &greq->header);
 
@@ -1867,13 +1867,13 @@ client_recv_guest_enter_by_name (void *cls, struct GNUNET_SERVER_Client *client,
 
   uint16_t app_id_size = strlen (app_id) + 1;
   gcls->app_id = GNUNET_malloc (app_id_size);
-  memcpy (gcls->app_id, app_id, app_id_size);
+  GNUNET_memcpy (gcls->app_id, app_id, app_id_size);
 
   uint16_t password_size = strlen (password);
   if (0 < password_size++)
   {
     gcls->password = GNUNET_malloc (password_size);
-    memcpy (gcls->password, password, password_size);
+    GNUNET_memcpy (gcls->password, password, password_size);
   }
 
   GNUNET_GNS_lookup (gns, gns_name, &greq->ego_pub_key,
@@ -1953,7 +1953,7 @@ app_notify_ego (struct Ego *ego, struct GNUNET_SERVER_Client *client)
   emsg->header.size = htons (sizeof (*emsg) + name_size);
 
   GNUNET_CRYPTO_ecdsa_key_get_public (&ego->key, &emsg->ego_pub_key);
-  memcpy (&emsg[1], ego->name, name_size);
+  GNUNET_memcpy (&emsg[1], ego->name, name_size);
 
   client_send_msg (client, &emsg->header);
   GNUNET_free (emsg);
@@ -2043,7 +2043,7 @@ client_recv_app_connect (void *cls, struct GNUNET_SERVER_Client *client,
 
   struct Client *ctx = GNUNET_new (struct Client);
   ctx->app_id = GNUNET_malloc (app_id_size);
-  memcpy (ctx->app_id, app_id, app_id_size);
+  GNUNET_memcpy (ctx->app_id, app_id, app_id_size);
 
   GNUNET_SERVER_client_set_user_context (client, ctx);
   GNUNET_SERVER_receive_done (client, GNUNET_OK);
@@ -2319,7 +2319,7 @@ psyc_transmit_notify_data (void *cls, uint16_t *data_size, void *data)
                 plc, pdata_size);
 
     *data_size = pdata_size;
-    memcpy (data, &pmsg[1], *data_size);
+    GNUNET_memcpy (data, &pmsg[1], *data_size);
     ret = GNUNET_NO;
     break;
 
@@ -2454,7 +2454,7 @@ psyc_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
     *full_value_size = ntohl (pmod->value_size);
     *oper = pmod->oper;
     *data_size = mod_size;
-    memcpy (data, &pmod[1], mod_size);
+    GNUNET_memcpy (data, &pmod[1], mod_size);
     ret = GNUNET_NO;
     break;
   }
@@ -2480,7 +2480,7 @@ psyc_transmit_notify_mod (void *cls, uint16_t *data_size, void *data,
                 "%p psyc_transmit_notify_mod: sending %u bytes.\n", plc, mod_size);
 
     *data_size = mod_size;
-    memcpy (data, &pmsg[1], *data_size);
+    GNUNET_memcpy (data, &pmsg[1], *data_size);
     ret = GNUNET_NO;
     break;
   }
@@ -2760,7 +2760,7 @@ psyc_transmit_queue_message (struct Place *plc,
 
   struct FragmentTransmitQueue *
     tmit_frag = GNUNET_malloc (sizeof (*tmit_frag) + data_size);
-  memcpy (&tmit_frag[1], data, data_size);
+  GNUNET_memcpy (&tmit_frag[1], data, data_size);
   tmit_frag->next_part = (struct GNUNET_MessageHeader *) &tmit_frag[1];
   tmit_frag->client = client;
   tmit_frag->size = data_size;
@@ -2893,7 +2893,7 @@ psyc_recv_history_message (void *cls, const struct GNUNET_PSYC_MessageHeader *ms
   res->op_id = opcls->op_id;
   res->result_code = GNUNET_htonll (GNUNET_OK);
 
-  memcpy (&res[1], msg, size);
+  GNUNET_memcpy (&res[1], msg, size);
 
   /** @todo FIXME: send only to requesting client */
   place_send_msg (plc, &res->header);
@@ -3001,7 +3001,7 @@ psyc_recv_state_var (void *cls,
   res->op_id = opcls->op_id;
   res->result_code = GNUNET_htonll (GNUNET_OK);
 
-  memcpy (&res[1], mod, size);
+  GNUNET_memcpy (&res[1], mod, size);
 
   /** @todo FIXME: send only to requesting client */
   place_send_msg (plc, &res->header);
@@ -3139,7 +3139,7 @@ client_recv_zone_add_place (void *cls, struct GNUNET_SERVER_Client *client,
   rec->place_pub_key = preq->place_pub_key;
   rec->origin = this_peer;
   rec->relay_count = preq->relay_count;
-  memcpy (&rec[1], relays, relay_size);
+  GNUNET_memcpy (&rec[1], relays, relay_size);
 
   rd.data = rec;
   rd.data_size = sizeof (*rec) + relay_size;
@@ -3439,7 +3439,7 @@ identity_recv_ego (void *cls, struct GNUNET_IDENTITY_Ego *id_ego,
     ego->key = *(GNUNET_IDENTITY_ego_get_private_key (id_ego));
     size_t name_size = strlen (name) + 1;
     ego->name = GNUNET_malloc (name_size);
-    memcpy (ego->name, name, name_size);
+    GNUNET_memcpy (ego->name, name, name_size);
 
     GNUNET_CONTAINER_multihashmap_put (egos, &ego_pub_hash, ego,
                                        GNUNET_CONTAINER_MULTIHASHMAPOPTION_REPLACE);
diff --git a/src/social/gnunet-social.c b/src/social/gnunet-social.c
index 7c36a96d4..ed3801abc 100644
--- a/src/social/gnunet-social.c
+++ b/src/social/gnunet-social.c
@@ -349,7 +349,7 @@ notify_data (void *cls, uint16_t *data_size, void *data)
   struct TransmitClosure *tmit = cls;
   uint16_t size = tmit->size < *data_size ? tmit->size : *data_size;
   *data_size = size;
-  memcpy (data, tmit->data, size);
+  GNUNET_memcpy (data, tmit->data, size);
 
   tmit->size -= size;
   tmit->data += size;
diff --git a/src/social/social_api.c b/src/social/social_api.c
index 5f144b88a..926995f6b 100644
--- a/src/social/social_api.c
+++ b/src/social/social_api.c
@@ -489,7 +489,7 @@ app_send_connect_msg (struct GNUNET_SOCIAL_App *app)
 {
   uint16_t cmsg_size = ntohs (app->connect_msg->size);
   struct GNUNET_MessageHeader * cmsg = GNUNET_malloc (cmsg_size);
-  memcpy (cmsg, app->connect_msg, cmsg_size);
+  GNUNET_memcpy (cmsg, app->connect_msg, cmsg_size);
   GNUNET_CLIENT_MANAGER_transmit_now (app->client, cmsg);
   GNUNET_free (cmsg);
 }
@@ -516,7 +516,7 @@ place_send_connect_msg (struct GNUNET_SOCIAL_Place *plc)
 {
   uint16_t cmsg_size = ntohs (plc->connect_msg->size);
   struct GNUNET_MessageHeader * cmsg = GNUNET_malloc (cmsg_size);
-  memcpy (cmsg, plc->connect_msg, cmsg_size);
+  GNUNET_memcpy (cmsg, plc->connect_msg, cmsg_size);
   GNUNET_CLIENT_MANAGER_transmit_now (plc->client, cmsg);
   GNUNET_free (cmsg);
 }
@@ -718,7 +718,7 @@ place_recv_state_result (void *cls,
     {
         look->mod_value_remaining = look->mod_value_size;
         look->mod_name = GNUNET_malloc (name_size);
-        memcpy (look->mod_name, name, name_size);
+        GNUNET_memcpy (look->mod_name, name, name_size);
     }
     break;
   }
@@ -911,12 +911,12 @@ app_recv_ego (void *cls,
     ego = GNUNET_malloc (sizeof (*ego));
     ego->pub_key = emsg->ego_pub_key;
     ego->name = GNUNET_malloc (name_size);
-    memcpy (ego->name, &emsg[1], name_size);
+    GNUNET_memcpy (ego->name, &emsg[1], name_size);
   }
   else
   {
     ego->name = GNUNET_realloc (ego->name, name_size);
-    memcpy (ego->name, &emsg[1], name_size);
+    GNUNET_memcpy (ego->name, &emsg[1], name_size);
   }
 
   GNUNET_CONTAINER_multihashmap_put (app->egos, &ego_pub_hash, ego,
@@ -1212,7 +1212,7 @@ GNUNET_SOCIAL_host_enter (const struct GNUNET_SOCIAL_App *app,
   hreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
   hreq->policy = policy;
   hreq->ego_pub_key = ego->pub_key;
-  memcpy (&hreq[1], app->id, app_id_size);
+  GNUNET_memcpy (&hreq[1], app->id, app_id_size);
 
   plc->connect_msg = &hreq->header;
   place_send_connect_msg (plc);
@@ -1280,7 +1280,7 @@ GNUNET_SOCIAL_host_enter_reconnect (struct GNUNET_SOCIAL_HostConnection *hconn,
   hreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_HOST_ENTER);
   hreq->place_pub_key = hconn->plc_msg.place_pub_key;
   hreq->ego_pub_key = hconn->plc_msg.ego_pub_key;
-  memcpy (&hreq[1], hconn->app->id, app_id_size);
+  GNUNET_memcpy (&hreq[1], hconn->app->id, app_id_size);
 
   plc->connect_msg = &hreq->header;
   place_send_connect_msg (plc);
@@ -1332,7 +1332,7 @@ GNUNET_SOCIAL_host_entry_decision (struct GNUNET_SOCIAL_Host *hst,
   dcsn->slave_pub_key = nym->pub_key;
 
   if (0 < entry_resp_size)
-    memcpy (&dcsn[1], entry_resp, entry_resp_size);
+    GNUNET_memcpy (&dcsn[1], entry_resp, entry_resp_size);
 
   GNUNET_CLIENT_MANAGER_transmit (hst->plc.client, &dcsn->header);
   GNUNET_free (dcsn);
@@ -1621,16 +1621,16 @@ guest_enter_request_create (const char *app_id,
   greq->relay_count = htonl (relay_count);
 
   char *p = (char *) &greq[1];
-  memcpy (p, app_id, app_id_size);
+  GNUNET_memcpy (p, app_id, app_id_size);
   p += app_id_size;
 
   if (0 < relay_size)
   {
-    memcpy (p, relays, relay_size);
+    GNUNET_memcpy (p, relays, relay_size);
     p += relay_size;
   }
 
-  memcpy (p, join_msg, join_msg_size);
+  GNUNET_memcpy (p, join_msg, join_msg_size);
   return greq;
 }
 
@@ -1765,14 +1765,14 @@ GNUNET_SOCIAL_guest_enter_by_name (const struct GNUNET_SOCIAL_App *app,
   greq->ego_pub_key = ego->pub_key;
 
   char *p = (char *) &greq[1];
-  memcpy (p, app->id, app_id_size);
+  GNUNET_memcpy (p, app->id, app_id_size);
   p += app_id_size;
-  memcpy (p, gns_name, gns_name_size);
+  GNUNET_memcpy (p, gns_name, gns_name_size);
   p += gns_name_size;
-  memcpy (p, password, password_size);
+  GNUNET_memcpy (p, password, password_size);
   p += password_size;
   if (NULL != join_msg)
-    memcpy (p, join_msg, join_msg_size);
+    GNUNET_memcpy (p, join_msg, join_msg_size);
 
   gst->enter_cb = local_enter_cb;
   gst->entry_dcsn_cb = entry_decision_cb;
@@ -1831,7 +1831,7 @@ GNUNET_SOCIAL_guest_enter_reconnect (struct GNUNET_SOCIAL_GuestConnection *gconn
   greq->place_pub_key = gconn->plc_msg.place_pub_key;
   greq->flags = htonl (flags);
 
-  memcpy (&greq[1], gconn->app->id, app_id_size);
+  GNUNET_memcpy (&greq[1], gconn->app->id, app_id_size);
 
   gst->enter_cb = local_enter_cb;
   gst->cb_cls = cls;
@@ -2023,7 +2023,7 @@ GNUNET_SOCIAL_place_msg_proc_set (struct GNUNET_SOCIAL_Place *plc,
   mpreq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_MSG_PROC_SET);
   mpreq->header.size = htons (sizeof (*mpreq) + method_size);
   mpreq->flags = htonl (flags);
-  memcpy (&mpreq[1], method_prefix, method_size);
+  GNUNET_memcpy (&mpreq[1], method_prefix, method_size);
 
   GNUNET_CLIENT_MANAGER_transmit (plc->client, &mpreq->header);
   GNUNET_free (mpreq);
@@ -2076,7 +2076,7 @@ place_history_replay (struct GNUNET_SOCIAL_Place *plc,
   req->message_limit = GNUNET_htonll (message_limit);
   req->flags = htonl (flags);
   req->op_id = GNUNET_htonll (hist->op_id);
-  memcpy (&req[1], method_prefix, method_size);
+  GNUNET_memcpy (&req[1], method_prefix, method_size);
 
   GNUNET_CLIENT_MANAGER_transmit (plc->client, &req->header);
   GNUNET_free (req);
@@ -2198,7 +2198,7 @@ place_state_get (struct GNUNET_SOCIAL_Place *plc,
   req->header.type = htons (type);
   req->header.size = htons (sizeof (*req) + name_size);
   req->op_id = GNUNET_htonll (look->op_id);
-  memcpy (&req[1], name, name_size);
+  GNUNET_memcpy (&req[1], name, name_size);
 
   GNUNET_CLIENT_MANAGER_transmit (plc->client, &req->header);
   GNUNET_free (req);
@@ -2349,11 +2349,11 @@ GNUNET_SOCIAL_zone_add_place (const struct GNUNET_SOCIAL_App *app,
   preq->relay_count = htonl (relay_count);
 
   char *p = (char *) &preq[1];
-  memcpy (p, name, name_size);
+  GNUNET_memcpy (p, name, name_size);
   p += name_size;
-  memcpy (p, password, password_size);
+  GNUNET_memcpy (p, password, password_size);
   p += password_size;
-  memcpy (p, relays, relay_size);
+  GNUNET_memcpy (p, relays, relay_size);
 
   struct ZoneAddPlaceHandle * add_plc = GNUNET_malloc (sizeof (*add_plc));
   add_plc->req = preq;
@@ -2426,7 +2426,7 @@ GNUNET_SOCIAL_zone_add_nym (const struct GNUNET_SOCIAL_App *app,
   nreq->expiration_time = GNUNET_htonll (expiration_time.abs_value_us);
   nreq->ego_pub_key = ego->pub_key;
   nreq->nym_pub_key = *nym_pub_key;
-  memcpy (&nreq[1], name, name_size);
+  GNUNET_memcpy (&nreq[1], name, name_size);
 
   struct ZoneAddNymHandle * add_nym = GNUNET_malloc (sizeof (*add_nym));
   add_nym->req = nreq;
@@ -2488,12 +2488,12 @@ GNUNET_SOCIAL_app_connect (const struct GNUNET_CONFIGURATION_Handle *cfg,
   GNUNET_CLIENT_MANAGER_set_user_context_ (app->client, app, sizeof (*app));
 
   app->id = GNUNET_malloc (app_id_size);
-  memcpy (app->id, id, app_id_size);
+  GNUNET_memcpy (app->id, id, app_id_size);
 
   struct AppConnectRequest *creq = GNUNET_malloc (sizeof (*creq) + app_id_size);
   creq->header.size = htons (sizeof (*creq) + app_id_size);
   creq->header.type = htons (GNUNET_MESSAGE_TYPE_SOCIAL_APP_CONNECT);
-  memcpy (&creq[1], app->id, app_id_size);
+  GNUNET_memcpy (&creq[1], app->id, app_id_size);
 
   app->connect_msg = &creq->header;
   app_send_connect_msg (app);
diff --git a/src/social/test_social.c b/src/social/test_social.c
index dd38a2920..dc73705c6 100644
--- a/src/social/test_social.c
+++ b/src/social/test_social.c
@@ -326,7 +326,7 @@ notify_data (void *cls, uint16_t *data_size, void *data)
   tmit->paused = GNUNET_NO;
 
   *data_size = size;
-  memcpy (data, tmit->data[tmit->n], size);
+  GNUNET_memcpy (data, tmit->data[tmit->n], size);
 
   return ++tmit->n < tmit->data_count ? GNUNET_NO : GNUNET_YES;
 }