step 3: bcopy->memcpy or memmove (chose by hand), twiddle args

git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@3816 dc483132-0cff-0310-8789-dd5450dbe970

10 files changed, 136 insertions, 256 deletions

diff --git a/src/isode/compat/bridge.c b/src/isode/compat/bridge.c
index d6fb02338..caa9ab0b4 100644
--- a/src/isode/compat/bridge.c
+++ b/src/isode/compat/bridge.c
@@ -9,24 +9,6 @@ static char *rcsid = "$Header$";
  *
  * Contributed by Julian Onions, Nottingham University in the UK
  *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:09  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:26:59  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:15:25  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:33:32  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:17:49  isode
- * Release 7.0
- * 
- * 
  */
 
 /*
@@ -367,14 +349,14 @@ IFP	writefnx;
     if (nsap == NULLNA || (na_stack = nsap -> na_stack) != NA_BRG)
 	return NOTOK;
     na_stack = htons(na_stack);
-    bcopy ((char *)&na_stack, buffer, sizeof(na_stack));
-    bcopy (nsap -> na_dte, &buffer[2], 16);
+    memcpy (buffer, (char *)&na_stack, sizeof(na_stack));
+    memcpy (&buffer[2], nsap -> na_dte, 16);
     buffer[18] = nsap -> na_dtelen;
-    bcopy (nsap -> na_pid, &buffer[19], 4);
+    memcpy (&buffer[19], nsap -> na_pid, 4);
     buffer[23] = nsap -> na_pidlen;
-    bcopy (nsap -> na_cudf, &buffer[24], 16);
+    memcpy (&buffer[24], nsap -> na_cudf, 16);
     buffer[40] = nsap -> na_cudflen;
-    bcopy (nsap -> na_fac, &buffer[41], 6);
+    memcpy (&buffer[41], nsap -> na_fac, 6);
     buffer[47] = nsap -> na_faclen;
     if ((*writefnx) (fd, buffer, 48) != 48)
 	return NOTOK;
@@ -393,18 +375,18 @@ IFP	readfnx;
 
     if (readx (fd, buffer, 48, readfnx) != 48)
 	return NOTOK;
-    bcopy (buffer, (char *)&na_stack, sizeof(na_stack));
+    memcpy ((char *)&na_stack, buffer, sizeof(na_stack));
     na_stack = ntohs(na_stack);
     if (na_stack != NA_BRG)
 	return NOTOK;
     nsap -> na_stack = na_stack;
-    bcopy (&buffer[2], nsap -> na_dte, 16);
+    memcpy (nsap -> na_dte, &buffer[2], 16);
     nsap -> na_dtelen = buffer[18];
-    bcopy (&buffer[19], nsap -> na_pid, 4);
+    memcpy (nsap -> na_pid, &buffer[19], 4);
     nsap -> na_pidlen = buffer[23];
-    bcopy (&buffer[24], nsap -> na_cudf, 16);
+    memcpy (nsap -> na_cudf, &buffer[24], 16);
     nsap -> na_cudflen = buffer[40];
-    bcopy (&buffer[41], nsap -> na_fac, 6);
+    memcpy (nsap -> na_fac, &buffer[41], 6);
     nsap -> na_faclen = buffer[47];
     return OK;
 }
diff --git a/src/isode/compat/dgram.c b/src/isode/compat/dgram.c
index cb2f0f765..2a3ff2f14 100644
--- a/src/isode/compat/dgram.c
+++ b/src/isode/compat/dgram.c
@@ -325,8 +325,8 @@ struct sockaddr *sock;
 
 	up = &peers[sd];
 #ifdef	BSD44
-	bcopy (qb -> qb_base, (caddr_t) sock,
-	       ((struct sockaddr *) qb -> qb_base) -> sa_len);
+	memcpy ((caddr_t) sock, qb -> qb_base,
+		((struct sockaddr *) qb -> qb_base) -> sa_len);
 #else
 	*sock = *((struct sockaddr *) qb -> qb_base);	/* struct copy */
 #endif
@@ -341,7 +341,7 @@ struct sockaddr *sock;
 #ifdef	BSD44
     if (sock -> sa_len == 0)
 	sock -> sa_len = sizeof *sock;
-    bcopy ((caddr_t) sock, (caddr_t) &up -> dgram_peer, sock -> sa_len);
+    memcpy ((caddr_t) &up -> dgram_peer, (caddr_t) sock, sock -> sa_len);
     {
 	struct sockaddr_in *sin;
 
@@ -422,7 +422,7 @@ struct  sockaddr *sock;
 #ifdef	BSD44
     if (sock -> sa_len == 0)
 	sock -> sa_len = sizeof *sock;
-    bcopy ((caddr_t) sock, (caddr_t) &up -> dgram_peer, sock -> sa_len);
+    memcpy ((caddr_t) &up -> dgram_peer, (caddr_t) sock, sock -> sa_len);
     up -> dgram_addrlen = 0;
 #else
     up -> dgram_peer.sa = *sock;	/* struct copy */
diff --git a/src/isode/compat/internet.c b/src/isode/compat/internet.c
index b4128ede1..9e6f77247 100644
--- a/src/isode/compat/internet.c
+++ b/src/isode/compat/internet.c
@@ -7,24 +7,6 @@ static char *rcsid = "$Header$";
 /* 
  * $Header$
  *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:16  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:27:24  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:15:52  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:33:53  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:17:56  isode
- * Release 7.0
- * 
- * 
  */
 
 /*
@@ -408,7 +390,7 @@ int	len,
 
     if (len != sizeof (long) || type != AF_INET)
 	return NULL;
-    bcopy (addr, (char *) &iaddr, len);
+    memcpy ((char *) &iaddr, addr, len);
     if ((name = raddr (iaddr)) == NULL)
 	return NULL;
 
diff --git a/src/isode/compat/isoaddrs.c b/src/isode/compat/isoaddrs.c
index 696250e72..66db28210 100644
--- a/src/isode/compat/isoaddrs.c
+++ b/src/isode/compat/isoaddrs.c
@@ -614,8 +614,9 @@ handle_dsp: ;
 
 				    if (ta -> ta_naddr >= NTADDR)
 					goto too_many;
-				    bcopy ((char *) (na - 1), (char *) na,
-					   sizeof *na);
+				    /* just copy one */
+				    memcpy ((char *) na, (char *) (na - 1),
+					    sizeof *na);
 				    (void) strcpy (na -> na_domain,
 					  inet_ntoa (*(struct in_addr *) *ap));
 				}
@@ -707,24 +708,24 @@ next: ;
     
     switch (sp - sels) {
         case 3:	/* PSEL+SSEL+TSEL */
-	    bcopy (*--sp, ta -> ta_selector,
-		   ta -> ta_selectlen = *--lp);
-	    bcopy (*--sp, sa -> sa_selector,
-		   sa -> sa_selectlen = *--lp);
-	    bcopy (*--sp, pa -> pa_selector,
-		   pa -> pa_selectlen = *--lp);
+	    memcpy (ta -> ta_selector, *--sp,
+		    ta -> ta_selectlen = *--lp);
+	    memcpy (sa -> sa_selector, *--sp,
+		    sa -> sa_selectlen = *--lp);
+	    memcpy (pa -> pa_selector, *--sp,
+		    pa -> pa_selectlen = *--lp);
 	    break;
 
 	case 2:	/* SSEL+TSEL */
-	    bcopy (*--sp, ta -> ta_selector,
-		   ta -> ta_selectlen = *--lp);
-	    bcopy (*--sp, sa -> sa_selector,
-		   sa -> sa_selectlen = *--lp);
+	    memcpy (ta -> ta_selector, *--sp,
+		    ta -> ta_selectlen = *--lp);
+	    memcpy (sa -> sa_selector, *--sp,
+		    sa -> sa_selectlen = *--lp);
 	    break;
 
 	case 1:	/* TSEL */
-	    bcopy (*--sp, ta -> ta_selector,
-		   ta -> ta_selectlen = *--lp);
+	    memcpy (ta -> ta_selector, *--sp,
+		    ta -> ta_selectlen = *--lp);
 	    break;
 
 	default:
diff --git a/src/isode/compat/na2norm.c b/src/isode/compat/na2norm.c
index d08ad994c..22aa5e9d4 100644
--- a/src/isode/compat/na2norm.c
+++ b/src/isode/compat/na2norm.c
@@ -7,24 +7,6 @@ static char *rcsid = "$Header$";
 /* 
  * $Header$
  *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:21  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:27:46  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:16:16  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:34:18  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:18:04  isode
- * Release 7.0
- * 
- * 
  */
 
 /*
@@ -150,7 +132,7 @@ register struct NSAPaddr *na;
 
     cp = nsap, dp = ca -> na_address;
     if (ts) {
-	bcopy (ts -> ts_prefix, dp, ts -> ts_length);
+	memcpy (dp, ts -> ts_prefix, ts -> ts_length);
 	dp += ts -> ts_length;
     }
     while (*cp) {
diff --git a/src/isode/compat/norm2na.c b/src/isode/compat/norm2na.c
index 3ce9abb8d..677c7ed7a 100644
--- a/src/isode/compat/norm2na.c
+++ b/src/isode/compat/norm2na.c
@@ -8,23 +8,6 @@ static char *rcsid = "$Header$";
  * $Header$
  *
  *
- * $Log$
- * Revision 1.2  1994/06/15 21:14:45  eichin
- * step 2: bcmp->memcmp
- *
- * Revision 1.1  1994/06/10 03:27:52  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:16:22  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:34:23  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:18:06  isode
- * Release 7.0
- * 
- * 
  */
 
 /*
@@ -282,7 +265,7 @@ unrealNS: ;
 		      ("NSAP address too long: %d octets", len));
 		return NOTOK;
 	    }
-	    bcopy (p, na -> na_address, na -> na_addrlen = len);
+	    memcpy (na -> na_address, p, na -> na_addrlen = len);
 	}
     }
 
diff --git a/src/isode/compat/pa2str.c b/src/isode/compat/pa2str.c
index 46670ab3e..e16c07d32 100644
--- a/src/isode/compat/pa2str.c
+++ b/src/isode/compat/pa2str.c
@@ -6,24 +6,6 @@ static char *rcsid = "$Header$";
 
 /* 
  * $Header$
- *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:23  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:27:54  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:16:23  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:34:25  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:18:07  isode
- * Release 7.0
- * 
  * 
  */
 
@@ -77,8 +59,8 @@ register struct PSAPaddr *px;
 	    tz = &px -> pa_addr.sa_addr;
 	    memset ((char *)ta, 0, sizeof *ta);
 	    if ((ta -> ta_selectlen = m - n - 2) > 0)
-		    bcopy (&tz -> ta_selector[n+2], ta -> ta_selector,
-			   ta -> ta_selectlen);
+		    memcpy (ta -> ta_selector, &tz -> ta_selector[n+2],
+			    ta -> ta_selectlen);
 	    if (norm2na (&tz -> ta_selector[2], n, ta -> ta_addrs) != OK) {
 		    *pa = *px;
 		    goto normal;
diff --git a/src/isode/compat/sunlink.c b/src/isode/compat/sunlink.c
index 1b32ded45..20638f40c 100644
--- a/src/isode/compat/sunlink.c
+++ b/src/isode/compat/sunlink.c
@@ -10,23 +10,6 @@ static char *rcsid = "$Header$";
  * Contributed by John Pavel, Department of Trade and Industry/National
  * Physical Laboratory in the UK
  * much hacked my others since then - i.e., don't blame John!
- *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:28  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:28:39  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:17:02  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:34:59  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:18:20  isode
- * Release 7.0
  * 
  * 
  */
@@ -145,9 +128,9 @@ int     backlog,
 		local -> na_pidlen = NPSIZE;
 	    *sock = *xs;	/* struct copy */
 	    memset((char *) sock -> data, 0, NPSIZE);
-	    bcopy (local -> na_pid, (char *) sock -> data, local -> na_pidlen);
-	    bcopy (local -> na_cudf, (char *) sock -> data + NPSIZE,
-		   local -> na_cudflen);
+	    memcpy ((char *) sock -> data, local -> na_pid, local -> na_pidlen);
+	    memcpy ((char *) sock -> data + NPSIZE, local -> na_cudf,
+		    local -> na_cudflen);
 	    sock -> datalen = local -> na_pidlen + local -> na_cudflen;
 	}
 	else
diff --git a/src/isode/compat/ubcx25.c b/src/isode/compat/ubcx25.c
index cdabf6577..db54df7ef 100644
--- a/src/isode/compat/ubcx25.c
+++ b/src/isode/compat/ubcx25.c
@@ -11,6 +11,9 @@ static char *rcsid = "$Header$";
  *
  *
  * $Log$
+ * Revision 1.2  1994/06/15 22:59:15  eichin
+ * step 3: bcopy->memcpy or memmove (chose by hand), twiddle args
+ *
  * Revision 1.1  1994/06/10 03:28:45  eichin
  * autoconfed isode for kerberos work
  *
@@ -288,7 +291,7 @@ char    *buffer;
     do {
 	count = len > X25_PACKETSIZE ? X25_PACKETSIZE : len;
 	mybuffer[0] = len > X25_PACKETSIZE ? X25_MBIT : 0;
-	bcopy (p, &mybuffer[1], count);
+	memcpy (&mybuffer[1], p, count);
 	switch (cc = write (fd, mybuffer, count + 1))
 	{
 	    case NOTOK:
diff --git a/src/isode/compat/x25addr.c b/src/isode/compat/x25addr.c
index ed1a49ad0..ef4653f9c 100644
--- a/src/isode/compat/x25addr.c
+++ b/src/isode/compat/x25addr.c
@@ -9,23 +9,6 @@ static char *rcsid = "$Header$";
  *
  * Contributed by George Michaelson, Julian Onions, and John Pavel
  *
- *
- * $Log$
- * Revision 1.2  1994/06/15 20:59:33  eichin
- * step 1: bzero->memset(,0,)
- *
- * Revision 1.1  1994/06/10 03:28:53  eichin
- * autoconfed isode for kerberos work
- *
- * Revision 1.1  94/06/10  03:17:16  eichin
- * autoconfed isode for kerberos work
- * 
- * Revision 1.1  1994/05/31 20:35:13  eichin
- * reduced-isode release from /mit/isode/isode-subset/src
- *
- * Revision 8.0  91/07/17  12:18:24  isode
- * Release 7.0
- * 
  * 
  */
 
@@ -108,20 +91,20 @@ int             context;
 	if ( strncmp(generic -> na_dte, x25_dnic_prefix,
 	    i = strlen(x25_dnic_prefix)) == 0 )
 	    {
-	    if (x25_strip_dnic) bcopy(generic -> na_dte + i, dte, dtelen =
-		generic -> na_dtelen - i);
-	    else bcopy (generic -> na_dte, dte, dtelen = generic -> na_dtelen);
+	    if (x25_strip_dnic) memcpy(dte, generic -> na_dte + i,
+				       dtelen = generic -> na_dtelen - i);
+	    else memcpy(dte, generic -> na_dte, dtelen = generic -> na_dtelen);
 	    }
 	else
 	    if (x25_intl_zero)
 		{
-		bcopy(generic -> na_dte, dte + 1, dtelen = generic-> na_dtelen);
+		memcpy(dte + 1, generic -> na_dte, dtelen = generic-> na_dtelen);
 		*dte = '0', dtelen++;
 		}
-	    else bcopy(generic -> na_dte, dte, dtelen = generic -> na_dtelen);
+	    else memcpy(dte, generic -> na_dte, dtelen = generic -> na_dtelen);
 
     }
-    else bcopy (generic -> na_dte, dte, dtelen = generic -> na_dtelen);
+    else memcpy (dte, generic -> na_dte, dtelen = generic -> na_dtelen);
     dte[dtelen] = NULL;
 
 #ifdef	SUN_X25_HACK
@@ -161,8 +144,8 @@ int             context;
 	if ( strncmp(generic -> na_dte, x25_local_dte,
 	    i = strlen(x25_local_dte)) == 0 ) 
 	    {
-	    bcopy(generic -> na_dte + i, dte, dtelen =
-		generic -> na_dtelen - i);
+	    memcpy(dte, generic -> na_dte + i, dtelen =
+		   generic -> na_dtelen - i);
     	    dte[dtelen] = NULL;
 	    }
 	}
@@ -180,21 +163,21 @@ int             context;
 
 #ifdef UBC_X25
     if ((specific -> xaddr_len = dtelen) != 0)  {
-	bcopy (dte, specific -> xaddr_addr,
-	       dtelen);
+	memcpy (specific -> xaddr_addr, dte,
+		dtelen);
 	specific -> xaddr_len = dtelen;
 	specific -> xaddr_facilities = 0;
-	bcopy (generic -> na_pid, specific -> xaddr_proto,
-	       generic -> na_pidlen);
-	bcopy (generic -> na_cudf, specific -> xaddr_userdata,
-	       generic -> na_cudflen);
+	memcpy (specific -> xaddr_proto, generic -> na_pid,
+		generic -> na_pidlen);
+	memcpy (specific -> xaddr_userdata, generic -> na_cudf,
+		generic -> na_cudflen);
     }
 #endif
 
 #ifdef HPUX_X25
     if ((dtelen != 1) || (dte [0] != '0'))
-	bcopy (dte, specific -> addr.x25_host,
-	       specific -> addr.x25hostlen = dtelen);
+	memcpy (specific -> addr.x25_host, dte,
+		specific -> addr.x25hostlen = dtelen);
 
     /* Zero PID */
     if (generic -> na_pidlen) { /* non-null PID */
@@ -204,10 +187,10 @@ int             context;
 	    return (CONN_DB *)0;
 	} else {
 	    memset((char *)specific -> addr.x25pid, 0, NPSIZE);
-	    bcopy (generic -> na_pid, (char *)specific -> addr.x25pid,
-		   specific -> addr.x25pidlen = generic -> na_pidlen);
-	    bcopy (generic -> na_pid, (char *)specific -> cudf.x25_cu_data,
-		   specific -> cudf.x25_cud_len = generic -> na_pidlen);
+	    memcpy ((char *)specific -> addr.x25pid, generic -> na_pid,
+		    specific -> addr.x25pidlen = generic -> na_pidlen);
+	    memcpy ((char *)specific -> cudf.x25_cu_data, generic -> na_pid,
+		    specific -> cudf.x25_cud_len = generic -> na_pidlen);
 	}
 	/* copy in CUDF */
 	if (generic -> na_cudflen) {
@@ -219,28 +202,27 @@ int             context;
 		       X25_MAX_CU_LEN));
 		return (CONN_DB *)0;
 	    } else {
-		bcopy (generic -> na_cudf,
-		       &specific -> cudf.x25_cu_data [specific -> cudf.x25_cud_len]
-		       ,
-		       generic -> na_cudflen);
+		memcpy (&specific -> cudf.x25_cu_data [specific -> cudf.x25_cud_len],
+			generic -> na_cudf,
+			generic -> na_cudflen);
 		specific -> cudf.x25_cud_len += generic -> na_cudflen;
 	    }
 	}
     } else {
 	/* PID ws empty, use first four Byte of cudf */
 	/* CUDF has PID - I hope so */
-	bcopy (generic -> na_cudf, specific -> addr.x25pid,
-	       specific -> addr.x25pidlen =
-	       (generic -> na_cudflen <= NPSIZE) ?
-	       generic -> na_cudflen : NPSIZE);
+	memcpy (specific -> addr.x25pid, generic -> na_cudf,
+		specific -> addr.x25pidlen =
+		(generic -> na_cudflen <= NPSIZE) ?
+		generic -> na_cudflen : NPSIZE);
 	if (generic -> na_cudflen > X25_MAX_CU_LEN) {
 	    SLOG (compat_log, LLOG_EXCEPTIONS, NULLCP,
 		  ("CALL-USERDATA too long (%d > %d)",
 		   generic -> na_cudflen - NPSIZE, X25_MAX_CU_LEN));
 	    return (CONN_DB *)0;
 	} else
-	    bcopy (generic -> na_cudf, specific -> cudf.x25_cu_data,
-		   specific -> cudf.x25_cud_len = generic -> na_cudflen);
+	    memcpy (specific -> cudf.x25_cu_data, generic -> na_cudf,
+		    specific -> cudf.x25_cud_len = generic -> na_cudflen);
     }
 
 #endif
@@ -256,16 +238,16 @@ int             context;
 	    return (CONN_DB *)0;
 	} else {
 	    memset((char *)specific -> data, 0, NPSIZE);
-	    bcopy (generic -> na_pid, (char *)specific -> data,
-		   generic -> na_pidlen);
-	    bcopy (generic -> na_cudf, (char *) specific -> data + NPSIZE,
-		   generic -> na_cudflen);
+	    memcpy ((char *)specific -> data, generic -> na_pid,
+		    generic -> na_pidlen);
+	    memcpy ((char *) specific -> data + NPSIZE, generic -> na_cudf,
+		    generic -> na_cudflen);
 	    specific -> datalen = generic -> na_pidlen + generic -> na_cudflen;
 	}
     } else { /* Null PID (just copy in CUDF, the first four octets of which
 		will be the PID in any case) */
-	 bcopy (generic -> na_cudf, (char *)specific -> data,
-		generic -> na_cudflen);
+	 memcpy ((char *)specific -> data, generic -> na_cudf,
+		 generic -> na_cudflen);
 	 specific -> datalen = generic -> na_cudflen;
     }
 #endif
@@ -292,7 +274,7 @@ int             context;
 	    }
 	    else {
 		iov -> iov_len = dtelen+1;
-		bcopy(dte, (iov -> iov_base)+1, dtelen);
+		memcpy((iov -> iov_base)+1, dte, dtelen);
 		*(iov -> iov_base) = x25_outgoing_port;
 	    }
 	    break;
@@ -309,8 +291,8 @@ int             context;
 		{                       /* listen on a PID */
 		register int i;
 		iov -> iov_base[0] = 'C';
-		bcopy(generic -> na_pid, iov -> iov_base + 1,
-		    i = generic -> na_pidlen);
+		memcpy(iov -> iov_base + 1, generic -> na_pid,
+		       i = generic -> na_pidlen);
 		iov -> iov_len = i + 1;
 		}
 	    else
@@ -318,13 +300,13 @@ int             context;
 		{           /* listen on a subaddress */
 		register int i;
 		iov -> iov_base[0] = 'S';
-		bcopy(generic -> na_dte, iov -> iov_base + 1,
-		    i = generic -> na_dtelen);
+		memcpy(iov -> iov_base + 1, generic -> na_dte,
+		       i = generic -> na_dtelen);
 		iov -> iov_len = i + 1;
 		}
 	    else    /* full DTE */
-		bcopy(dte, iov -> iov_base,
-		    iov -> iov_len = dtelen);
+		memcpy(iov -> iov_base, dte,
+		       iov -> iov_len = dtelen);
 	    return (specific);
     }
     /*
@@ -336,11 +318,11 @@ int             context;
 
     (iov = &(specific -> ccl_iovec[2])) -> iov_len = 0;
     if (generic -> na_faclen != 0)
-	bcopy (generic -> na_fac, 0, iov -> iov_base,
-	    iov -> iov_len = min( generic -> na_faclen, FACSIZE) );
+	memcpy ( iov -> iov_base, generic -> na_fac,
+		iov -> iov_len = min( generic -> na_faclen, FACSIZE) );
     iov++;
     if ( (iov -> iov_len = generic -> na_pidlen) != 0)
-	bcopy (generic -> na_pid, iov -> iov_base, generic -> na_pidlen);
+	memcpy ( iov -> iov_base, generic -> na_pid, generic -> na_pidlen);
 
     /*
      * if there is any other user data add that in now...
@@ -349,29 +331,29 @@ int             context;
      */
 
     if (generic -> na_cudflen != 0)
-	bcopy(generic -> na_cudf, iov -> iov_base + iov -> iov_len,
-	    generic -> na_cudflen), iov -> iov_len += generic -> na_cudflen;
+	memcpy(iov -> iov_base + iov -> iov_len, generic -> na_cudf,
+	       generic -> na_cudflen), iov -> iov_len += generic -> na_cudflen;
 #endif
 
 #ifdef	ULTRIX_X25
     if (generic -> na_dtelen  != 0) {
         specific -> na_dtelen = specific -> na_pidlen 
 		= specific -> na_cudflen = 0;
-	bcopy (generic -> na_dte, 
-	       specific -> na_dte, 
-	       specific -> na_dtelen = generic -> na_dtelen);
+	memcpy (specific -> na_dte,
+		generic -> na_dte, 
+		specific -> na_dtelen = generic -> na_dtelen);
         /*
          * concatenate PID and CUDF into CUDF buffer.
          */
         if (generic -> na_pidlen > 0) {
-	    bcopy (generic -> na_pid, 
-		   specific -> na_cudf, 
-	           specific -> na_cudflen = generic -> na_pidlen);
+	    memcpy (specific -> na_cudf,
+		    generic -> na_pid, 
+		    specific -> na_cudflen = generic -> na_pidlen);
         }
         if (generic -> na_cudflen > 0) {
-	    bcopy (generic -> na_cudf, 
-	           specific -> na_cudf + specific -> na_pidlen, 
-	           generic -> na_cudflen);
+	    memcpy (specific -> na_cudf + specific -> na_pidlen,
+		    generic -> na_cudf, 
+		    generic -> na_cudflen);
 	    specific -> na_cudflen += generic -> na_cudflen;
         }
     }
@@ -407,13 +389,13 @@ int             context;
 
 #ifdef UBC_X25
     if (specific -> xaddr_len  != 0) {
-	bcopy (specific -> xaddr_addr, dte, specific -> xaddr_len);
+	memcpy (dte, specific -> xaddr_addr, specific -> xaddr_len);
 	dtelen = specific -> xaddr_len;
-	bcopy (specific -> xaddr_proto, generic -> na_pid,
-				sizeof(specific -> xaddr_proto));
+	memcpy (generic -> na_pid, specific -> xaddr_proto,
+		sizeof(specific -> xaddr_proto));
 	generic -> na_pidlen = sizeof specific -> xaddr_proto;
-	bcopy (specific -> xaddr_userdata, generic -> na_cudf,
-				sizeof(specific -> xaddr_userdata));
+	memcpy (generic -> na_cudf, specific -> xaddr_userdata,
+		sizeof(specific -> xaddr_userdata));
 	generic -> na_cudflen = sizeof specific -> xaddr_userdata;
     }
 #endif
@@ -422,15 +404,15 @@ int             context;
     dtelen = bcd2char (specific -> host, dte, (int) specific -> hostlen);
 
     if (specific -> datalen > NPSIZE) { /* have some real user data after the PID */
-	bcopy((char *)specific -> data, generic -> na_pid,
-	      generic -> na_pidlen = NPSIZE);
-	bcopy((char *) specific -> data + generic -> na_pidlen,
-	      generic -> na_cudf,
-	      generic -> na_cudflen = specific -> datalen - generic -> na_pidlen);
+	memcpy(generic -> na_pid, (char *)specific -> data,
+	       generic -> na_pidlen = NPSIZE);
+	memcpy(generic -> na_cudf, 
+	       (char *) specific -> data + generic -> na_pidlen,
+	       generic -> na_cudflen = specific -> datalen - generic -> na_pidlen);
     }
     else { /* PID only */
-	bcopy((char *)specific -> data, generic -> na_pid,
-	      generic -> na_pidlen = specific -> datalen);
+	memcpy(generic -> na_pid, (char *)specific -> data,
+	       generic -> na_pidlen = specific -> datalen);
 	generic -> na_cudflen = 0;
     }
 
@@ -438,8 +420,8 @@ int             context;
 
 #ifdef HPUX_X25
     if (specific -> addr.x25hostlen)
-	bcopy (specific -> addr.x25_host, dte,
-	       dtelen = specific -> addr.x25hostlen);
+	memcpy (dte, specific -> addr.x25_host,
+		dtelen = specific -> addr.x25hostlen);
     else {
 	dte [0] = '0';
 	dte [1] = NULL;
@@ -451,12 +433,12 @@ int             context;
 	      ("PID too long (%d > %d)", specific -> addr.x25pidlen, NPSIZE));
 	specific -> addr.x25pidlen = NPSIZE;
     }
-    bcopy((char *)specific -> addr.x25pid, generic -> na_pid,
-	  generic -> na_pidlen = specific -> addr.x25pidlen);
+    memcpy(generic -> na_pid, (char *)specific -> addr.x25pid,
+	   generic -> na_pidlen = specific -> addr.x25pidlen);
 
     if (specific -> cudf.x25_cud_len) {
-	bcopy (specific -> cudf.x25_cu_data, generic -> na_cudf,
-	       generic -> na_cudflen = specific -> cudf.x25_cud_len);
+	memcpy (generic -> na_cudf, specific -> cudf.x25_cu_data,
+		generic -> na_cudflen = specific -> cudf.x25_cud_len);
     }
 #endif
 
@@ -484,12 +466,12 @@ int             context;
 				dtelen = 0;
 			else {
 				dtelen = iov -> iov_len;
-				bcopy (a, dte, dtelen);
+				memcpy (dte, a, dtelen);
 			}
 		}
 		else {
 			dtelen = iov -> iov_len - 1;
-			bcopy ((iov -> iov_base)+1, dte,
+			memcpy (dte, (iov -> iov_base)+1,
 				dtelen);
 		}
 	}
@@ -500,7 +482,7 @@ int             context;
 	iov = &(specific -> ccl_iovec[0]);
 	if (iov -> iov_len) {
 		dtelen = iov -> iov_len -1;
-		bcopy ((iov -> iov_base)+1, dte,
+		memcpy (dte, (iov -> iov_base)+1,
 			dtelen);
 	}
 	else dtelen = 0;
@@ -511,22 +493,22 @@ int             context;
     }
 
     if ( (iov = &(specific -> ccl_iovec[2])) -> iov_len )
-	bcopy( iov -> iov_base, generic -> na_fac,
-	    generic -> na_faclen = min( iov -> iov_len, FACSIZE));
+	memcpy(generic -> na_fac,  iov -> iov_base,
+	       generic -> na_faclen = min( iov -> iov_len, FACSIZE));
 
     if ( ++iov -> iov_len)
 	{
-	bcopy( iov -> iov_base, generic -> na_pid,
-	    generic -> na_pidlen = min( iov -> iov_len, NPSIZE));
+	memcpy(generic -> na_pid,  iov -> iov_base,
+	       generic -> na_pidlen = min( iov -> iov_len, NPSIZE));
 	if ( iov -> iov_len > NPSIZE)
-	    bcopy( iov -> iov_base + NPSIZE, generic -> na_cudf,
-		generic -> na_cudflen = min(iov -> iov_len - NPSIZE, CUDFSIZE));
+	    memcpy(generic -> na_cudf,  iov -> iov_base + NPSIZE,
+		   generic -> na_cudflen = min(iov -> iov_len - NPSIZE, CUDFSIZE));
 	}
 #endif
 
 #ifdef	ULTRIX_X25
     if (specific -> na_dtelen  > 0) {
-	bcopy (specific -> na_dte, dte, specific -> na_dtelen);
+	memcpy (dte, specific -> na_dte, specific -> na_dtelen);
 	dtelen = specific -> na_dtelen;
 
 	/*
@@ -534,14 +516,14 @@ int             context;
 	 * bytes into pid field and shift remainder down.
 	 */
 	if (specific -> na_cudflen > 0) {
-	    bcopy(specific -> na_cudf, 
-		  generic -> na_pid, 
-		  generic -> na_pidlen = (specific -> na_cudflen <= NPSIZE ? 
-		   			  specific -> na_cudflen : NPSIZE));
+	    memcpy(generic -> na_pid,
+		   specific -> na_cudf, 
+		   generic -> na_pidlen = (specific -> na_cudflen <= NPSIZE ? 
+					   specific -> na_cudflen : NPSIZE));
 	    if (specific -> na_cudflen > NPSIZE) {
-	        bcopy(specific -> na_cudf + NPSIZE, 
-		      generic -> na_cudf, 
-		      generic -> na_cudflen = specific -> na_cudflen - NPSIZE);
+	        memcpy(generic -> na_cudf,
+		       specific -> na_cudf + NPSIZE, 
+		       generic -> na_cudflen = specific -> na_cudflen - NPSIZE);
 	    }
 	} else {
 	    generic -> na_pidlen = 0;
@@ -563,14 +545,14 @@ int             context;
 		    && *x25_dnic_prefix
 		    && x25_strip_dnic
 		    && dtelen < 12)   /* local call... */
-		bcopy (x25_dnic_prefix, generic -> na_dte,
-		       generic -> na_dtelen = strlen (x25_dnic_prefix));
+		memcpy (generic -> na_dte, x25_dnic_prefix,
+			generic -> na_dtelen = strlen (x25_dnic_prefix));
 
-	bcopy (dte + i, generic -> na_dte + generic -> na_dtelen, dtelen - i);
+	memcpy (generic -> na_dte + generic -> na_dtelen, dte + i, dtelen - i);
 	generic -> na_dtelen += dtelen - i;
     }
     else
-	bcopy (dte, generic -> na_dte, generic -> na_dtelen = dtelen);
+	memcpy (generic -> na_dte, dte, generic -> na_dtelen = dtelen);
 
     DLOG (x25_log, LLOG_DEBUG,
 	   ("if2gen %s -> %s, %d octets; PID %s",