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

diff --git a/src/isode/compat/bridge.c b/src/isode/compat/bridge.c
index d6fb0233864e1267db4c2a03ae3299509eed0c79..caa9ab0b4cb6ac4c1adb98558389ffd12b87380a 100644 (file)
--- 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 cb2f0f76565254ad3bd6e12de360203e98b32765..2a3ff2f143899b4f6a0dc8ae9e15b7de1c24f49c 100644 (file)
--- 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 b4128ede140ac0a647152a0d1bb7104abdd2c2ed..9e6f7724756f868b9a6589c4e57028e9fe1e0c52 100644 (file)
--- 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 696250e72fb0f6d9b8ae7d50b677a1eaebe98d93..66db2821029e481f18c04ceac48ac7f32ca60694 100644 (file)
--- 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 d08ad994c2022deab42cf8e3078f5ffdd0ef723f..22aa5e9d4ccf89198c0cef556d5f97701e442f1f 100644 (file)
--- 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 3ce9abb8ddc9fefbbe4a5119fd882e207e3ebcf4..677c7ed7a289c4fa55cd4fae09431fce66757dfc 100644 (file)
--- 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 46670ab3ed314e048868f54bab06df2e6d1552b2..e16c07d32bb8d25ca1b66dd17855c42b80c61e53 100644 (file)
--- 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 1b32ded45074307b6bc38b5369d743d39f5f9ada..20638f40c9bf6332f25f4ea40962ae9115f6890e 100644 (file)
--- 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 cdabf6577cb4b69b8c49b81cf995f6ea517c5582..db54df7ef29e5b2694a725f26fd0882abf590eb4 100644 (file)
--- 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 ed1a49ad0ea21aa02c76bba641b2b094ab6536af..ef4653f9c32cb9fa99e5078037adada02e1e3198 100644 (file)
--- 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",