path: root/debian/patches/0005-Replace-bcopy-with-memcpy-or-memmove-as-appropriate.patch

From 82a87d043498eeacb7e4f3edc85d1b7c424ea853 Mon Sep 17 00:00:00 2001
From: Justus Winter <4winter@informatik.uni-hamburg.de>
Date: Tue, 2 Dec 2014 00:20:51 +0100
Subject: [PATCH hurd 5/5] Replace `bcopy' with `memcpy' or `memmove' as
 appropriate

* ext2fs/inode.c: Replace `bcopy' with `memcpy' or `memmove' as
appropriate.
* ext2fs/pager.c: Likewise.
* isofs/lookup.c: Likewise.
* isofs/main.c: Likewise.
* isofs/rr.c: Likewise.
* libdiskfs/file-get-trans.c: Likewise.
* libiohelp/return-buffer.c: Likewise.
* libpager/pagemap.c: Likewise.
* libpipe/pq.c: Likewise.
* libpipe/pq.h: Likewise.
* libstore/unzipstore.c: Likewise.
* mach-defpager/default_pager.c: Likewise.
* pfinet/ethernet.c: Likewise.
* pfinet/tunnel.c: Likewise.
* storeio/dev.c: Likewise.
---
 ext2fs/inode.c                |  6 +++---
 ext2fs/pager.c                |  4 ++--
 isofs/lookup.c                |  4 ++--
 isofs/main.c                  |  2 +-
 isofs/rr.c                    |  6 +++---
 libdiskfs/file-get-trans.c    | 10 +++++-----
 libiohelp/return-buffer.c     |  2 +-
 libpager/pagemap.c            |  2 +-
 libpipe/pq.c                  | 12 ++++++------
 libpipe/pq.h                  |  2 +-
 libstore/unzipstore.c         |  6 +++---
 mach-defpager/default_pager.c |  4 ++--
 pfinet/ethernet.c             | 10 +++++-----
 pfinet/tunnel.c               |  2 +-
 storeio/dev.c                 |  6 +++---
 15 files changed, 39 insertions(+), 39 deletions(-)

diff --git a/ext2fs/inode.c b/ext2fs/inode.c
index 27530fb..6b8b749 100644
--- a/ext2fs/inode.c
+++ b/ext2fs/inode.c
@@ -733,7 +733,7 @@ diskfs_set_translator (struct node *np, const char *name, unsigned namelen,
 
       buf[0] = namelen & 0xFF;
       buf[1] = (namelen >> 8) & 0xFF;
-      bcopy (name, buf + 2, namelen);
+      memcpy (buf + 2, name, namelen);
 
       blkptr = disk_cache_block_ref (blkno);
       memcpy (blkptr, buf, block_size);
@@ -805,7 +805,7 @@ write_symlink (struct node *node, const char *target)
 
   assert (node->dn_stat.st_blocks == 0);
 
-  bcopy (target, node->dn->info.i_data, len);
+  memcpy (node->dn->info.i_data, target, len);
   node->dn_stat.st_size = len - 1;
   node->dn_set_ctime = 1;
   node->dn_set_mtime = 1;
@@ -822,7 +822,7 @@ read_symlink (struct node *node, char *target)
 
   assert (node->dn_stat.st_size < MAX_INODE_SYMLINK);
 
-  bcopy (node->dn->info.i_data, target, node->dn_stat.st_size);
+  memcpy (target, node->dn->info.i_data, node->dn_stat.st_size);
   return 0;
 }
 
diff --git a/ext2fs/pager.c b/ext2fs/pager.c
index ae51530..a6c4fbb 100644
--- a/ext2fs/pager.c
+++ b/ext2fs/pager.c
@@ -209,7 +209,7 @@ file_pager_read_page (struct node *node, vm_offset_t page,
 	      else
 		/* We've already got some buffer, so copy into it.  */
 		{
-		  bcopy (new_buf, *buf + offs, new_len);
+		  memcpy (*buf + offs, new_buf, new_len);
 		  free_page_buf (new_buf); /* Return NEW_BUF to our pool.  */
 		  STAT_INC (file_pagein_freed_bufs);
 		}
@@ -316,7 +316,7 @@ pending_blocks_write (struct pending_blocks *pb)
 	/* Put what we're going to write into a page-aligned buffer.  */
 	{
 	  void *page_buf = get_page_buf ();
-	  bcopy (pb->buf + pb->offs, (void *)page_buf, length);
+	  memcpy ((void *)page_buf, pb->buf + pb->offs, length);
 	  err = store_write (store, dev_block, page_buf, length, &amount);
 	  free_page_buf (page_buf);
 	}
diff --git a/isofs/lookup.c b/isofs/lookup.c
index b5b814d..e51b9cb 100644
--- a/isofs/lookup.c
+++ b/isofs/lookup.c
@@ -338,7 +338,7 @@ diskfs_get_directs (struct node *dp,
 			   (ouralloc
 			    ? (allocsize *= 2)
 			    : (allocsize = vm_page_size * 2)), 1);
-	      bcopy ((void *) *data, (void *)newdata, datap - *data);
+	      memcpy ((void *) newdata, (void *) *data, datap - *data);
 
 	      if (ouralloc)
 		munmap (*data, allocsize / 2);
@@ -374,7 +374,7 @@ diskfs_get_directs (struct node *dp,
 	  userp->d_type = DT_UNKNOWN;
 	  userp->d_reclen = reclen;
 	  userp->d_namlen = namlen;
-	  bcopy (name, userp->d_name, namlen);
+	  memcpy (userp->d_name, name, namlen);
 	  userp->d_name[namlen] = '\0';
 
 	  /* And move along */
diff --git a/isofs/main.c b/isofs/main.c
index 5d002af..4f531f7 100644
--- a/isofs/main.c
+++ b/isofs/main.c
@@ -101,7 +101,7 @@ read_sblock ()
   sblock = malloc (sizeof (struct sblock));
   if (!sblock)
     error (1, errno, "Could not allocate memory for superblock");
-  bcopy (sb, sblock, sizeof (struct sblock));
+  memcpy (sblock, sb, sizeof (struct sblock));
   diskfs_end_catch_exception ();
 
   /* Parse some important bits of this */
diff --git a/isofs/rr.c b/isofs/rr.c
index be4395d..adc95c3 100644
--- a/isofs/rr.c
+++ b/isofs/rr.c
@@ -282,7 +282,7 @@ rrip_work (struct dirrect *dr, struct rrip_lookup *rr,
 	    nmbuf = realloc (nmbuf, (nmbufsize += nmlen) + 1);
 	  assert (nmbuf);
 
-	  bcopy (nm->name, nmbuf + nmbufsize - nmlen, nmlen);
+	  memcpy (nmbuf + nmbufsize - nmlen, nm->name, nmlen);
 
 	  if (nm->flags & NAME_CONTINUE)
 	    goto next_field;
@@ -375,7 +375,7 @@ rrip_work (struct dirrect *dr, struct rrip_lookup *rr,
 		rr->target = realloc (rr->target, targalloced *= 2);
 	      assert (rr->target);
 
-	      bcopy (cname, rr->target + targused, cnamelen);
+	      memcpy (rr->target + targused, cname, cnamelen);
 	      targused += cnamelen;
 	    }
 
@@ -391,7 +391,7 @@ rrip_work (struct dirrect *dr, struct rrip_lookup *rr,
 	    slbuf = realloc (slbuf, slbufsize += crlen);
 	  assert (slbuf);
 
-	  bcopy (sl->data, slbuf + slbufsize - crlen, crlen);
+	  memcpy (slbuf + slbufsize - crlen, sl->data, crlen);
 
 	  if (sl->flags & 1)
 	    /* We'll finish later. */
diff --git a/libdiskfs/file-get-trans.c b/libdiskfs/file-get-trans.c
index db5bbda..e6e994d 100644
--- a/libdiskfs/file-get-trans.c
+++ b/libdiskfs/file-get-trans.c
@@ -45,7 +45,7 @@ diskfs_S_file_get_translator (struct protid *cred,
       assert (diskfs_shortcut_symlink);
       if (len > *translen)
 	*trans = mmap (0, len, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
-      bcopy (_HURD_SYMLINK, *trans, sizeof _HURD_SYMLINK);
+      memcpy (*trans, _HURD_SYMLINK, sizeof _HURD_SYMLINK);
 
       if (diskfs_read_symlink_hook)
 	err = (*diskfs_read_symlink_hook) (np,
@@ -85,7 +85,7 @@ diskfs_S_file_get_translator (struct protid *cred,
 
       if (buflen > *translen)
 	*trans = mmap (0, buflen, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
-      bcopy (buf, *trans, buflen);
+      memcpy (*trans, buf, buflen);
       free (buf);
       *translen = buflen;
       err = 0;
@@ -97,7 +97,7 @@ diskfs_S_file_get_translator (struct protid *cred,
       len = sizeof _HURD_FIFO;
       if (len > *translen)
 	*trans = mmap (0, len, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
-      bcopy (_HURD_FIFO, *trans, sizeof _HURD_FIFO);
+      memcpy (*trans, _HURD_FIFO, sizeof _HURD_FIFO);
       *translen = len;
       err = 0;
     }
@@ -108,7 +108,7 @@ diskfs_S_file_get_translator (struct protid *cred,
       len = sizeof _HURD_IFSOCK;
       if (len > *translen)
 	*trans = mmap (0, len, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
-      bcopy (_HURD_IFSOCK, *trans, sizeof _HURD_IFSOCK);
+      memcpy (*trans, _HURD_IFSOCK, sizeof _HURD_IFSOCK);
       *translen = len;
       err = 0;
     }
@@ -125,7 +125,7 @@ diskfs_S_file_get_translator (struct protid *cred,
 	    {
 	      if (len > *translen)
 		*trans = mmap (0, len, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
-	      bcopy (string, *trans, len);
+	      memcpy (*trans, string, len);
 	      *translen = len;
 	      free (string);
 	    }
diff --git a/libiohelp/return-buffer.c b/libiohelp/return-buffer.c
index e186698..1beb4ae 100644
--- a/libiohelp/return-buffer.c
+++ b/libiohelp/return-buffer.c
@@ -44,7 +44,7 @@ iohelp_return_malloced_buffer (char *buf, size_t len,
   if (! err)
     {
       if (len)
-	bcopy (buf, *rbuf, len);
+	memcpy (*rbuf, buf, len);
       *rlen = len;
     }
 
diff --git a/libpager/pagemap.c b/libpager/pagemap.c
index b8b3362..963f656 100644
--- a/libpager/pagemap.c
+++ b/libpager/pagemap.c
@@ -36,7 +36,7 @@ _pager_pagemap_resize (struct pager *p, vm_address_t off)
       err = (newaddr == (void *) -1) ? errno : 0;
       if (! err)
 	{
-	  bcopy (p->pagemap, newaddr, p->pagemapsize * sizeof (*p->pagemap));
+	  memcpy (newaddr, p->pagemap, p->pagemapsize * sizeof (*p->pagemap));
 	  munmap (p->pagemap, p->pagemapsize * sizeof (*p->pagemap));
 	  p->pagemap = newaddr;
 	  p->pagemapsize = newsize;
diff --git a/libpipe/pq.c b/libpipe/pq.c
index 102f3ee..fe7dd8a 100644
--- a/libpipe/pq.c
+++ b/libpipe/pq.c
@@ -249,10 +249,10 @@ packet_realloc (struct packet *packet, size_t new_len)
 	/* If there was an operation like vm_move, we could use that in the
 	   case where both the old and the new buffers were vm_alloced (on
 	   the assumption that creating COW pages is somewhat more costly).
-	   But there's not, and bcopy will do vm_copy where it can.  Will we
+	   But there's not, and memcpy may do vm_copy where it can.  Will we
 	   still takes faults on the new copy, even though we've deallocated
 	   the old one???  XXX */
-	bcopy (start, new_buf, end - start);
+	memcpy (new_buf, start, end - start);
 
       /* And get rid of the old buffer.  */
       if (old_len > 0)
@@ -305,7 +305,7 @@ packet_set_ports (struct packet *packet,
       packet->ports = new_ports;
       packet->ports_alloced = num_ports;
     }
-  bcopy (ports, packet->ports, sizeof (mach_port_t) * num_ports);
+  memcpy (packet->ports, ports, sizeof (mach_port_t) * num_ports);
   packet->num_ports = num_ports;
   return 0;
 }
@@ -324,7 +324,7 @@ packet_read_ports (struct packet *packet,
 	return errno;
     }
   *num_ports = packet->num_ports;
-  bcopy (packet->ports, *ports, length);
+  memcpy (*ports, packet->ports, length);
   packet->num_ports = 0;
   return 0;
 }
@@ -341,7 +341,7 @@ packet_write (struct packet *packet,
     return err;
 
   /* Add the new data.  */
-  bcopy (data, packet->buf_end, data_len);
+  memcpy (packet->buf_end, data, data_len);
   packet->buf_end += data_len;
   if (amount != NULL)
     *amount = data_len;
@@ -411,7 +411,7 @@ packet_fetch (struct packet *packet,
 	  if (*data_len < amount)
 	    *data = mmap (0, amount, PROT_READ|PROT_WRITE, MAP_ANON, 0, 0);
 
-	  bcopy (start, *data, amount);
+	  memcpy (*data, start, amount);
 	  start += amount;
 
 	  if (remove && start - buf > 2 * PACKET_SIZE_LARGE)
diff --git a/libpipe/pq.h b/libpipe/pq.h
index 4e500b6..7238ace 100644
--- a/libpipe/pq.h
+++ b/libpipe/pq.h
@@ -176,7 +176,7 @@ packet_fit (struct packet *packet, size_t amount)
 	   than 25% of the buffer size, then move the data instead of growing
 	   the buffer. */
 	{
-	  bcopy (start, buf, cur_len);
+	  memmove (buf, start, cur_len);
 	  packet->buf_start = buf;
 	  packet->buf_end = buf + cur_len;
 	}
diff --git a/libstore/unzipstore.c b/libstore/unzipstore.c
index 8d500c1..cc86887 100644
--- a/libstore/unzipstore.c
+++ b/libstore/unzipstore.c
@@ -81,7 +81,7 @@ unzip_store (struct store *from, void **buf, size_t *buf_len)
 	    {
 	      if (left > maxread)
 		left = maxread;
-	      bcopy (in_buf + in_buf_offs, buf, left);
+	      memcpy (buf, in_buf + in_buf_offs, left);
 	      in_buf_offs += left;
 	      buf += left;
 	      maxread -= left;
@@ -150,7 +150,7 @@ unzip_store (struct store *from, void **buf, size_t *buf_len)
 
 	      if (out_buf_offs > 0)
 		/* Copy the old buffer into the start of the new & free it. */
-		bcopy (old_buf, new_buf, out_buf_offs);
+		memcpy (new_buf, old_buf, out_buf_offs);
 
 	      munmap (old_buf, old_buf_len);
 
@@ -160,7 +160,7 @@ unzip_store (struct store *from, void **buf, size_t *buf_len)
 	  *buf_len = new_buf_len;
 	}
 
-      bcopy (wbuf, *buf + out_buf_offs, nwrite);
+      memcpy (*buf + out_buf_offs, wbuf, nwrite);
       out_buf_offs += nwrite;
     }
 
diff --git a/mach-defpager/default_pager.c b/mach-defpager/default_pager.c
index 9e4b0e7..83382c0 100644
--- a/mach-defpager/default_pager.c
+++ b/mach-defpager/default_pager.c
@@ -431,7 +431,7 @@ create_paging_partition(const char *name,
 			memset (new_list, 0, n * sizeof(partition_t));
 			if (i) {
 			    old_list = all_partitions.partition_list;
-			    bcopy(old_list, new_list, i*sizeof(partition_t));
+			    memcpy (new_list, old_list, i*sizeof(partition_t));
 			}
 			all_partitions.partition_list = new_list;
 			all_partitions.n_partitions = n;
@@ -1678,7 +1678,7 @@ ddprintf ("default_read(%x,%x,%x,%d)\n",addr,size,offset,block.block.p_index);
 	     * the next piece.
 	     */
 	    first_time = FALSE;
-	    bcopy((char *)raddr, (char *)addr, rsize);
+	    memcpy ((char *)addr, (char *)raddr, rsize);
 	    addr += rsize;
 	    offset += rsize;
 	    size -= rsize;
diff --git a/pfinet/ethernet.c b/pfinet/ethernet.c
index 1678243..e6ae53c 100644
--- a/pfinet/ethernet.c
+++ b/pfinet/ethernet.c
@@ -158,10 +158,10 @@ ethernet_demuxer (mach_msg_header_t *inp,
   skb->dev = dev;
 
   /* Copy the two parts of the frame into the buffer. */
-  bcopy (msg->header, skb->data, ETH_HLEN);
-  bcopy (msg->packet + sizeof (struct packet_header),
-	 skb->data + ETH_HLEN,
-	 datalen - ETH_HLEN);
+  memcpy (skb->data, msg->header, ETH_HLEN);
+  memcpy (skb->data + ETH_HLEN,
+	  msg->packet + sizeof (struct packet_header),
+	  datalen - ETH_HLEN);
 
   /* Drop it on the queue. */
   skb->protocol = eth_type_trans (skb, dev);
@@ -389,7 +389,7 @@ setup_ethernet_device (char *name, struct device **device)
     error (2, err, "%s: Cannot get hardware Ethernet address", name);
   net_address[0] = ntohl (net_address[0]);
   net_address[1] = ntohl (net_address[1]);
-  bcopy (net_address, dev->dev_addr, ETH_ALEN);
+  memcpy (dev->dev_addr, net_address, ETH_ALEN);
 
   /* That should be enough.  */
 
diff --git a/pfinet/tunnel.c b/pfinet/tunnel.c
index 6a7f355..02e9ee8 100644
--- a/pfinet/tunnel.c
+++ b/pfinet/tunnel.c
@@ -395,7 +395,7 @@ trivfs_S_io_write (struct trivfs_protid *cred,
   skb->len = datalen;
   skb->dev = &tdev->dev;
 
-  bcopy (data, skb->data, datalen);
+  memcpy (skb->data, data, datalen);
 
   /* Drop it on the queue. */
   skb->mac.raw = skb->data;
diff --git a/storeio/dev.c b/storeio/dev.c
index 8f520cd..614c257 100644
--- a/storeio/dev.c
+++ b/storeio/dev.c
@@ -336,7 +336,7 @@ dev_write (struct dev *dev, off_t offs, void *buf, size_t len,
 {
   error_t buf_write (size_t buf_offs, size_t io_offs, size_t len)
     {
-      bcopy (buf + io_offs, dev->buf + buf_offs, len);
+      memcpy (dev->buf + buf_offs, buf + io_offs, len);
       dev->buf_dirty = 1;
       return 0;
     }
@@ -398,7 +398,7 @@ dev_read (struct dev *dev, off_t offs, size_t whole_amount,
     {
       error_t err = ensure_buf ();
       if (! err)
-	bcopy (dev->buf + buf_offs, *buf + io_offs, len);
+	memcpy (*buf + io_offs, dev->buf + buf_offs, len);
       return err;
     }
   error_t raw_read (off_t offs, size_t io_offs, size_t len, size_t *amount)
@@ -424,7 +424,7 @@ dev_read (struct dev *dev, off_t offs, size_t whole_amount,
 		  if (req_buf != _req_buf)
 		    /* Copy from wherever the read put it. */
 		    {
-		      bcopy (req_buf, _req_buf, req_len);
+		      memcpy (_req_buf, req_buf, req_len);
 		      munmap (req_buf, req_len);
 		    }
 		  *amount = req_len;
-- 
2.1.3