- add argus

4 files changed, 1381 insertions, 0 deletions

diff --git a/package/Config.in b/package/Config.in
index ecf982cf6..dc928e3e4 100644
--- a/package/Config.in
+++ b/package/Config.in
@@ -25,6 +25,7 @@ source "package/tar/Config.in"
 
 comment "Other stuff"
 source "package/acpid/Config.in"
+source "package/argus/Config.in"
 source "package/asterisk/Config.in"
 source "package/at/Config.in"
 source "package/autoconf/Config.in"
@@ -66,6 +67,7 @@ source "package/iproute2/Config.in"
 source "package/ipsec-tools/Config.in"
 source "package/iptables/Config.in"
 source "package/jpeg/Config.in"
+source "package/kexec/Config.in"
 source "package/less/Config.in"
 source "package/libcgi/Config.in"
 source "package/libcgicc/Config.in"
diff --git a/package/argus/Config.in b/package/argus/Config.in
new file mode 100644
index 000000000..958ecdda8
--- /dev/null
+++ b/package/argus/Config.in
@@ -0,0 +1,9 @@
+config BR2_PACKAGE_ARGUS
+	bool "argus"
+	default n
+	select BR2_PACKAGE_LIBPCAP
+	help
+	  A Real Time Flow Monitor-based audit engine.
+
+	  http://qosient.com/argus/
+
diff --git a/package/argus/argus-3.0.0.rc.34-00-susv3-legacy.patch b/package/argus/argus-3.0.0.rc.34-00-susv3-legacy.patch
new file mode 100644
index 000000000..a439050a1
--- /dev/null
+++ b/package/argus/argus-3.0.0.rc.34-00-susv3-legacy.patch
@@ -0,0 +1,1278 @@
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusApp.c argus-3.0.0.rc.34/argus/ArgusApp.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusApp.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusApp.c	2006-12-20 16:21:04.000000000 +0100
+@@ -196,9 +196,9 @@ ArgusUpdateAppState (struct ArgusModeler
+                                     net->hdr.argus_dsrvl8.qual = 0;
+                                     net->hdr.argus_dsrvl8.len  = ((sizeof(struct ArgusRTCPObject) + 3)/4) + 1;
+                                     if (model->ArgusThisDir) {
+-                                       bcopy ((char *) rtcp, (char *)&rtcpObject->src, sizeof(*rtcp));
++                                       memmove ((char *)&rtcpObject->src, (char *) rtcp, sizeof(*rtcp));
+                                     } else {
+-                                       bcopy ((char *) rtcp, (char *)&rtcpObject->dst, sizeof(*rtcp));
++                                       memmove ((char *)&rtcpObject->dst, (char *) rtcp, sizeof(*rtcp));
+                                     }
+ 
+                                  } else {
+@@ -215,9 +215,9 @@ ArgusUpdateAppState (struct ArgusModeler
+                                        rtp->rh_ssrc = ntohl(rtp->rh_ssrc);
+ 
+                                        if (model->ArgusThisDir) {
+-                                          bcopy ((char *) rtp, (char *)&rtpObject->src, sizeof(*rtp));
++                                          memmove ((char *)&rtpObject->src, (char *) rtp, sizeof(*rtp));
+                                        } else {
+-                                          bcopy ((char *) rtp, (char *)&rtpObject->dst, sizeof(*rtp));
++                                          memmove ((char *)&rtpObject->dst, (char *) rtp, sizeof(*rtp));
+                                        }
+                                     }
+                                  }
+@@ -301,7 +301,7 @@ ArgusUpdateAppState (struct ArgusModeler
+ 
+                   if ((bytes = model->ArgusThisSnapEnd - model->ArgusThisUpHdr) > 0) {
+                      thislen = (thislen > bytes) ? bytes : thislen;
+-                     bcopy (model->ArgusThisUpHdr, &((char *)&user->array)[user->count], thislen);
++                     memmove (&((char *)&user->array)[user->count], model->ArgusThisUpHdr, thislen);
+                      user->count += thislen;
+                   }
+                }
+@@ -358,7 +358,7 @@ ArgusUpdateRTPState (struct ArgusModeler
+                ArgusThisRtpHdr = &rtpObject->dst;
+ 
+             if (!(ArgusThisRtpHdr->rh_seq)) {
+-               bcopy ((char *) rtp, (char *)ArgusThisRtpHdr, sizeof(*rtp));
++               memmove ((char *)ArgusThisRtpHdr, (char *) rtp, sizeof(*rtp));
+             } else {
+                if (!(rtp->rh_ssrc) || (ArgusThisRtpHdr->rh_ssrc != rtp->rh_ssrc))
+                   flowstr->dsrs[ARGUS_NETWORK_INDEX] = NULL;
+@@ -404,7 +404,7 @@ ArgusUpdateRTPState (struct ArgusModeler
+                }
+             }
+  
+-            bcopy ((char *) rtp, (char *) ArgusThisRtpHdr, sizeof(*rtp));
++            memmove ((char *) ArgusThisRtpHdr, (char *) rtp, sizeof(*rtp));
+       
+             model->ArgusThisUpHdr = (unsigned char *)(rtp + 1) + offset;
+             model->ArgusThisLength -= (sizeof(struct rtphdr) + offset);
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusArp.c argus-3.0.0.rc.34/argus/ArgusArp.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusArp.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusArp.c	2006-12-20 16:12:05.000000000 +0100
+@@ -81,8 +81,8 @@ ArgusCreateArpFlow (struct ArgusModelerS
+          case ARPOP_REQUEST:
+             retn->hdr.argus_dsrvl8.qual = ARGUS_TYPE_ARP;
+             srcehost = (unsigned char *) &model->ArgusThisEpHdr->ether_shost;
+-            bcopy ((char *)&arp->arp_tpa, &arp_tpa, sizeof(arp_tpa));
+-            bcopy ((char *)&arp->arp_spa, &arp_spa, sizeof(arp_spa));
++            memmove (&arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_tpa));
++            memmove (&arp_spa, (char *)&arp->arp_spa, sizeof(arp_spa));
+ #ifdef _LITTLE_ENDIAN
+             arp_spa = ntohl(arp_spa);
+             arp_tpa = ntohl(arp_tpa);
+@@ -90,7 +90,7 @@ ArgusCreateArpFlow (struct ArgusModelerS
+             if (arp_spa > arp_tpa)
+                model->state |= ARGUS_DIRECTION;
+ 
+-            bcopy (srcehost, retn->arp_flow.etheraddr, sizeof (retn->arp_flow.etheraddr));
++            memmove (retn->arp_flow.etheraddr, srcehost, sizeof (retn->arp_flow.etheraddr));
+ 
+             retn->arp_flow.arp_tpa = arp_tpa;
+             retn->arp_flow.arp_spa = arp_spa;
+@@ -101,8 +101,8 @@ ArgusCreateArpFlow (struct ArgusModelerS
+             retn->hdr.argus_dsrvl8.qual = ARGUS_TYPE_ARP;
+             srcehost = (unsigned char *) &model->ArgusThisEpHdr->ether_dhost;
+ 
+-            bcopy ((char *)&arp->arp_spa, &arp_spa, sizeof(arp_tpa));
+-            bcopy ((char *)&arp->arp_tpa, &arp_tpa, sizeof(arp_spa));
++            memmove (&arp_spa, (char *)&arp->arp_spa, sizeof(arp_tpa));
++            memmove (&arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_spa));
+ #ifdef _LITTLE_ENDIAN
+             arp_spa = ntohl(arp_spa);
+             arp_tpa = ntohl(arp_tpa);
+@@ -111,7 +111,7 @@ ArgusCreateArpFlow (struct ArgusModelerS
+             if (arp_tpa > arp_spa)
+                model->state |= ARGUS_DIRECTION;
+    
+-            bcopy (srcehost, retn->arp_flow.etheraddr, sizeof (retn->arp_flow.etheraddr));
++            memmove (retn->arp_flow.etheraddr, srcehost, sizeof (retn->arp_flow.etheraddr));
+ 
+             retn->arp_flow.arp_tpa = arp_tpa;
+             retn->arp_flow.arp_spa = arp_spa;
+@@ -120,29 +120,29 @@ ArgusCreateArpFlow (struct ArgusModelerS
+ 
+          case REVARP_REQUEST:
+             retn->hdr.argus_dsrvl8.qual = ARGUS_TYPE_RARP;
+-            bcopy ((char *)&arp->arp_tpa, &arp_tpa, sizeof(arp_tpa));
++            memmove (&arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_tpa));
+ #ifdef _LITTLE_ENDIAN
+             arp_tpa = ntohl(arp_tpa);
+ #endif
+ 
+             srcehost = (unsigned char *)&THA(arp);
+             tarehost = (unsigned char *)&SHA(arp);
+-            bcopy ((char *)&arp->arp_tpa, &retn->rarp_flow.arp_tpa, sizeof(arp_tpa));
+-            bcopy (srcehost, retn->rarp_flow.srceaddr, sizeof (retn->rarp_flow.srceaddr));
+-            bcopy (tarehost, retn->rarp_flow.tareaddr, sizeof (retn->rarp_flow.tareaddr));
++            memmove (&retn->rarp_flow.arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_tpa));
++            memmove (retn->rarp_flow.srceaddr, srcehost, sizeof (retn->rarp_flow.srceaddr));
++            memmove (retn->rarp_flow.tareaddr, tarehost, sizeof (retn->rarp_flow.tareaddr));
+             break;
+ 
+          case REVARP_REPLY:
+             retn->hdr.argus_dsrvl8.qual = ARGUS_TYPE_RARP;
+-            bcopy ((char *)&arp->arp_tpa, &arp_tpa, sizeof(arp_tpa));
++            memmove (&arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_tpa));
+ #ifdef _LITTLE_ENDIAN
+             arp_tpa = ntohl(arp_tpa);
+ #endif
+             srcehost = (unsigned char *)&SHA(arp);
+             tarehost = (unsigned char *)&THA(arp);
+-            bcopy ((char *)&arp->arp_tpa, &retn->rarp_flow.arp_tpa, sizeof(arp_tpa));
+-            bcopy (srcehost, retn->rarp_flow.srceaddr, sizeof (retn->rarp_flow.srceaddr));
+-            bcopy (tarehost, retn->rarp_flow.tareaddr, sizeof (retn->rarp_flow.tareaddr));
++            memmove (&retn->rarp_flow.arp_tpa, (char *)&arp->arp_tpa, sizeof(arp_tpa));
++            memmove (retn->rarp_flow.srceaddr, srcehost, sizeof (retn->rarp_flow.srceaddr));
++            memmove (retn->rarp_flow.tareaddr, tarehost, sizeof (retn->rarp_flow.tareaddr));
+             break;
+       }
+    }
+@@ -177,7 +177,7 @@ ArgusUpdateArpState (struct ArgusModeler
+             break;
+ 
+          case ARPOP_REPLY:
+-            bcopy ((unsigned char *)&SHA(arp), arpobj->respaddr, 6);
++            memmove (arpobj->respaddr, (unsigned char *)&SHA(arp), 6);
+             break;
+       }
+    }
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusEsp.c argus-3.0.0.rc.34/argus/ArgusEsp.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusEsp.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusEsp.c	2006-12-20 15:57:17.000000000 +0100
+@@ -123,7 +123,7 @@ ArgusUpdateESPState (struct ArgusModeler
+ 
+          flowstr->dsrs[ARGUS_NETWORK_INDEX] = (void *) net;
+ 
+-         bzero ((char *)espObj, sizeof(*espObj));
++         memset ((char *)espObj, 0, sizeof(*espObj));
+          flowstr->timeout = ARGUS_IPTIMEOUT;
+ 
+          espObj->spi     = esp->spi;
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusFrag.c argus-3.0.0.rc.34/argus/ArgusFrag.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusFrag.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusFrag.c	2006-12-20 16:18:25.000000000 +0100
+@@ -232,7 +232,7 @@ ArgusUpdateFRAGState (struct ArgusModele
+                            if (prvfragOffset != NULL) {
+                               prvfragOffset->nxt = fragOffset->nxt;
+                            } else {
+-                              bcopy((char *) fragOffset->nxt , (char *)&frag->offsets, sizeof(frag->offsets));
++                              memmove((char *)&frag->offsets, (char *) fragOffset->nxt, sizeof(frag->offsets));
+                            }
+ /* else just update the prv fragments pointer to toss this one */
+                         } else {
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusIcmp.c argus-3.0.0.rc.34/argus/ArgusIcmp.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusIcmp.c	2006-10-30 19:26:51.000000000 +0100
++++ argus-3.0.0.rc.34/argus/ArgusIcmp.c	2006-12-20 16:07:09.000000000 +0100
+@@ -159,8 +159,9 @@ ArgusCreateICMPFlow (struct ArgusModeler
+ 
+                         case ICMP_UNREACH_NET:
+                         case ICMP_UNREACH_HOST:
+-                           bcopy ((char *) &icmp->icmp_ip.ip_dst.s_addr,
+-                                           (char *)&icmpFlow->id, sizeof (int));
++                           memmove ((char *)&icmpFlow->id,
++					   (char*) &icmp->icmp_ip.ip_dst.s_addr,
++                                           sizeof (int));
+                            break;
+                      }
+                      break;
+@@ -174,7 +175,7 @@ ArgusCreateICMPFlow (struct ArgusModeler
+ 
+                         case ICMP_REDIRECT_NET:
+                         case ICMP_REDIRECT_HOST:
+-                           bcopy ((char *) &icmp->icmp_ip.ip_dst.s_addr, (char *)&icmpFlow->id, sizeof (int));
++                           memmove ((char *)&icmpFlow->id, (char *) &icmp->icmp_ip.ip_dst.s_addr, sizeof (int));
+                            break;
+                      }
+                      break;
+@@ -220,7 +221,7 @@ ArgusUpdateICMPState (struct ArgusModele
+          net->hdr.subtype          = ARGUS_ICMP_DSR;
+          net->hdr.argus_dsrvl8.qual = 0;
+          net->hdr.argus_dsrvl8.len  = ((sizeof(struct ArgusICMPObject)+3))/4 + 1;
+-         bzero ((char *)icmpObj, sizeof(*icmpObj));
++         memset ((char *)icmpObj, 0, sizeof(*icmpObj));
+ 
+          icmpObj->icmp_type = icmp->icmp_type;
+          icmpObj->icmp_code = icmp->icmp_code;
+@@ -314,7 +315,7 @@ ArgusUpdateICMPState (struct ArgusModele
+                   }
+ 
+                   dsr->argus_dsrvl8.len  = (sizeof (struct ArgusIcmpStruct) + 3)/4 + 1;
+-                  bcopy ((char *) icmpObj, (char *) (dsr + 1), sizeof (*icmpObj));
++                  memmove ((char *) (dsr + 1), (char *) icmpObj, sizeof (*icmpObj));
+                   flow->dsrs[ARGUS_ICMP_INDEX] = dsr;
+                   flow->dsrindex |= 1 << ARGUS_ICMP_INDEX;
+ 
+@@ -361,7 +362,7 @@ ArgusUpdateICMPv6State (struct ArgusMode
+          net->hdr.subtype          = ARGUS_ICMP_DSR;
+          net->hdr.argus_dsrvl8.qual = 0;
+          net->hdr.argus_dsrvl8.len  = ((sizeof(struct ArgusICMPObject)+3))/4 + 1;
+-         bzero ((char *)icmpObj, sizeof(*icmpObj));
++         memset ((char *)icmpObj, 0, sizeof(*icmpObj));
+ 
+          icmpObj->icmp_type = icmpv6->icmp6_type;
+          icmpObj->icmp_code = icmpv6->icmp6_code;
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusMac.c argus-3.0.0.rc.34/argus/ArgusMac.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusMac.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusMac.c	2006-12-20 16:18:44.000000000 +0100
+@@ -44,7 +44,7 @@ ArgusMacFlowRecord (struct ArgusFlowStru
+    struct ArgusMacStruct *mac = (struct ArgusMacStruct *) flowstr->MacDSRBuffer;
+       
+    if (mac && ((length = argus->ahdr.length) > 0)) {
+-      bcopy ((char *)mac, &((char *)argus)[argus->ahdr.length], sizeof(*mac));
++      memmove (&((char *)argus)[argus->ahdr.length], (char *)mac, sizeof(*mac));
+       argus->ahdr.length += sizeof(*mac);
+    }
+ }
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusModeler.c argus-3.0.0.rc.34/argus/ArgusModeler.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusModeler.c	2006-09-26 06:28:16.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusModeler.c	2006-12-20 16:17:19.000000000 +0100
+@@ -112,7 +112,7 @@ void *ArgusQueueManager(void *);
+ void
+ ArgusInitModeler(struct ArgusModelerStruct *model)
+ {
+-   bzero (model->ArgusTimeOutQueues, sizeof(model->ArgusTimeOutQueues));
++   memset (model->ArgusTimeOutQueues, 0, sizeof(model->ArgusTimeOutQueues));
+    model->ArgusInProtocol = 1;
+    model->ArgusUpdateInterval.tv_usec = 200000;
+    model->ArgusMajorVersion = VERSION_MAJOR;
+@@ -525,7 +525,7 @@ ArgusProcessPacketHdrs (struct ArgusMode
+                model->ArgusThisEncaps |= ARGUS_ENCAPS_LLC;
+ 
+                llc = model->ArgusThisLLC;
+-               bcopy((char *) ptr, (char *) llc, sizeof (struct llc));
++               memmove((char *) llc, (char *) ptr, sizeof (struct llc));
+ 
+ #define ARGUS_IPX_TAG         100
+ 
+@@ -772,7 +772,7 @@ ArgusProcessEtherHdr (struct ArgusModele
+          model->ArgusThisEncaps |= ARGUS_ENCAPS_LLC;
+ 
+          llc = model->ArgusThisLLC;
+-         bcopy((char *) ptr, (char *) llc, sizeof (struct llc));
++         memmove((char *) llc, (char *) ptr, sizeof (struct llc));
+ 
+ #define ARGUS_IPX_TAG         100
+ 
+@@ -1314,11 +1314,11 @@ ArgusCreateFlow (struct ArgusModelerStru
+                   }
+ 
+                   if (dstgteq) {
+-                     bcopy ((char *) ep, (char *)&model->ArgusThisFlow->mac_flow.ehdr, sizeof (struct ether_header));
++                     memmove ((char *)&model->ArgusThisFlow->mac_flow.ehdr, (char *) ep, sizeof (struct ether_header));
+                   } else {
+                      model->state |= ARGUS_DIRECTION;
+-                     bcopy ((char *)&ep->ether_shost, (char *)&model->ArgusThisFlow->mac_flow.ehdr.ether_dhost, ETH_ALEN);
+-                     bcopy ((char *)&ep->ether_dhost, (char *)&model->ArgusThisFlow->mac_flow.ehdr.ether_shost, ETH_ALEN);
++                     memmove ((char *)&model->ArgusThisFlow->mac_flow.ehdr.ether_dhost, (char *)&ep->ether_shost, ETH_ALEN);
++                     memmove ((char *)&model->ArgusThisFlow->mac_flow.ehdr.ether_shost, (char *)&ep->ether_dhost, ETH_ALEN);
+                      model->ArgusThisFlow->mac_flow.ehdr.ether_type = ep->ether_type;
+                   }
+ 
+@@ -1418,7 +1418,7 @@ ArgusNewFlow (struct ArgusModelerStruct 
+       retn->qhdr.qtime.tv_sec  = 0;
+       retn->qhdr.qtime.tv_usec = 0;
+ 
+-      bzero ((char *)retn->dsrs, sizeof(retn->dsrs));
++      memset ((char *)retn->dsrs, 0, sizeof(retn->dsrs));
+ 
+       retn->dsrs[ARGUS_TRANSPORT_INDEX] = &retn->canon.trans.hdr;
+       trans = (struct ArgusTransportStruct *) retn->dsrs[ARGUS_TRANSPORT_INDEX];
+@@ -1429,7 +1429,7 @@ ArgusNewFlow (struct ArgusModelerStruct 
+ 
+       retn->dsrs[ARGUS_TIME_INDEX] = (struct ArgusDSRHeader *) &retn->canon.time.hdr;
+       dtime = (struct ArgusTimeObject *) retn->dsrs[ARGUS_TIME_INDEX];
+-      bzero((char *)dtime, sizeof(*dtime));
++      memset((char *)dtime, 0, sizeof(*dtime));
+       dtime->hdr.type            = ARGUS_TIME_DSR;
+       dtime->hdr.subtype         = ARGUS_TIME_ABSOLUTE_TIMESTAMP;
+       dtime->hdr.argus_dsrvl8.qual = ARGUS_TYPE_UTC_MICROSECONDS;
+@@ -1446,10 +1446,10 @@ ArgusNewFlow (struct ArgusModelerStruct 
+       retn->dsrs[ARGUS_FLOW_INDEX] = (struct ArgusDSRHeader *) &retn->canon.flow.hdr;
+       retn->canon.flow.hdr = flow->hdr;
+ 
+-      bcopy ((char *)&flow->flow_un, (char *)&retn->canon.flow.flow_un, (flow->hdr.argus_dsrvl8.len - 1) * 4);
++      memmove ((char *)&retn->canon.flow.flow_un, (char *)&flow->flow_un, (flow->hdr.argus_dsrvl8.len - 1) * 4);
+       retn->dsrindex |= 1 << ARGUS_FLOW_INDEX;
+ 
+-      bzero ((char *)&retn->canon.metric, sizeof(retn->canon.metric));
++      memset ((char *)&retn->canon.metric, 0, sizeof(retn->canon.metric));
+ /*
+       if (retn->status & ARGUS_DIRECTION)
+          retn->dsrs[ARGUS_FLOW_INDEX]->subtype |= ARGUS_REVERSE;
+@@ -1573,7 +1573,7 @@ ArgusUpdateBasicFlow (struct ArgusModele
+          mac->hdr.argus_dsrvl8.len    = 5;
+ 
+          if (model->ArgusThisEpHdr != NULL)
+-            bcopy ((char *)model->ArgusThisEpHdr, (char *)&mac->mac_union.ether, sizeof(struct ether_header));
++            memmove ((char *)&mac->mac_union.ether, (char *)model->ArgusThisEpHdr, sizeof(struct ether_header));
+ 
+          flow->dsrindex |= 1 << ARGUS_MAC_INDEX;
+ 
+@@ -1652,8 +1652,8 @@ ArgusUpdateBasicFlow (struct ArgusModele
+          jitter->hdr.argus_dsrvl8.len       = 1;
+          flow->dsrindex |= 1 << ARGUS_JITTER_INDEX;
+ 
+-         bzero((char *)&jitter->act,  sizeof(struct ArgusJitterObject));
+-         bzero((char *)&jitter->idle, sizeof(struct ArgusJitterObject));
++         memset((char *)&jitter->act, 0, sizeof(struct ArgusJitterObject));
++         memset((char *)&jitter->idle, 0, sizeof(struct ArgusJitterObject));
+ 
+          memset(&flow->stime.act,  0, sizeof(flow->stime.act));
+          memset(&flow->stime.idle, 0, sizeof(flow->stime.idle));
+@@ -2094,7 +2094,7 @@ ArgusGenerateRecord (struct ArgusModeler
+          int i, x, len = 0, type = 0, dsrlen = 1;
+          struct ArgusDSRHeader *dsr;
+ 
+-         bcopy ((char *)&rec->hdr, (char *)&retn->hdr, sizeof(retn->hdr));
++         memmove ((char *)&retn->hdr, (char *)&rec->hdr, sizeof(retn->hdr));
+          dsrptr = (unsigned int *)&retn->ar_un.mar;
+ 
+          if ((rec->canon.trans.seqnum = model->ArgusSeqNum++) == 0xFFFFFFFF)
+@@ -2441,7 +2441,7 @@ ArgusGenerateRecord (struct ArgusModeler
+          retn->hdr.len = dsrlen;
+ 
+       } else  {
+-         bcopy ((char *)&rec->canon, (char *) retn, rec->hdr.len * 4);
++         memmove ((char *) retn, (char *)&rec->canon, rec->hdr.len * 4);
+          retn->hdr = rec->hdr;
+       }
+          
+@@ -2470,8 +2470,8 @@ ArgusCopyRecordStruct (struct ArgusRecor
+ 
+    if (rec) {
+       if ((retn = (struct ArgusRecordStruct *) ArgusMallocListRecord (sizeof(*retn))) != NULL) {
+-         bcopy ((char *)&rec->hdr, (char *)&retn->hdr, sizeof (rec->hdr));
+-         bcopy ((char *)&rec->canon, (char *)&retn->canon, sizeof (rec->canon));
++         memmove ((char *)&retn->hdr, (char *)&rec->hdr, sizeof (rec->hdr));
++         memmove ((char *)&retn->canon, (char *)&rec->canon, sizeof (rec->canon));
+ 
+          if ((retn->dsrindex = rec->dsrindex)) {
+             for (i = 0; i < ARGUSMAXFLOWTYPE; i++) {
+@@ -2494,7 +2494,7 @@ ArgusCopyRecordStruct (struct ArgusRecor
+                         struct ArgusDataStruct *user = (struct ArgusDataStruct *) rec->dsrs[i];
+                         if (user->count > 0) {
+                            if ((retn->dsrs[i] = (void *) ArgusCalloc(1, (8 + user->size))) != NULL) {
+-                              bcopy ((char *)rec->dsrs[i], (char *)retn->dsrs[i], 8 + user->size);
++                              memmove ((char *)retn->dsrs[i], (char *)rec->dsrs[i], 8 + user->size);
+                            } else {
+                               retn->dsrindex &= ~(0x01 << i);
+                            }
+@@ -2541,7 +2541,7 @@ ArgusGenerateListRecord (struct ArgusMod
+ 
+    if ((retn = (struct ArgusRecordStruct *) ArgusMallocListRecord (sizeof(*retn))) != NULL) {
+       if (flow) {
+-         bcopy ((char *)&flow->canon, (char *)&retn->canon, sizeof (flow->canon));
++         memmove ((char *)&retn->canon, (char *)&flow->canon, sizeof (flow->canon));
+          if ((retn->dsrindex = flow->dsrindex) != 0) {
+             for (i = 0; i < ARGUSMAXFLOWTYPE; i++) {
+                if (flow->dsrs[i] != NULL) {
+@@ -2691,8 +2691,8 @@ ArgusGenerateListRecord (struct ArgusMod
+ 
+       } else {
+          retn->dsrindex = 0;
+-         bzero ((char *)&retn->canon, sizeof(retn->canon));
+-         bzero ((char *)retn->dsrs, sizeof(retn->dsrs));
++         memset ((char *)&retn->canon, 0, sizeof(retn->canon));
++         memset ((char *)retn->dsrs, 0, sizeof(retn->dsrs));
+       }
+ 
+       if (!(flow) && ((state == ARGUS_STOP) || (state == ARGUS_ERROR))) {
+@@ -3017,7 +3017,7 @@ ArgusCreateIPv4Flow (struct ArgusModeler
+       model->ArgusSnapLength -= hlen;
+ 
+       if (model->ArgusFlowKey & ARGUS_FLOW_KEY_CLASSIC5TUPLE) {
+-         bzero ((char *)model->ArgusThisFlow, sizeof(*model->ArgusThisFlow));
++         memset ((char *)model->ArgusThisFlow, 0, sizeof(*model->ArgusThisFlow));
+          model->ArgusThisFlow->hdr.type             = ARGUS_FLOW_DSR;
+          model->ArgusThisFlow->hdr.subtype          = ARGUS_FLOW_CLASSIC5TUPLE;
+          model->ArgusThisFlow->hdr.argus_dsrvl8.qual = ARGUS_TYPE_IPV4;
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusOutput.c argus-3.0.0.rc.34/argus/ArgusOutput.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusOutput.c	2006-10-16 21:57:15.000000000 +0200
++++ argus-3.0.0.rc.34/argus/ArgusOutput.c	2006-12-20 16:21:26.000000000 +0100
+@@ -530,7 +530,7 @@ ArgusEstablishListen (struct ArgusOutput
+ #endif
+          if ((host = gethostbyname (bindIP)) != NULL) {
+             if ((host->h_addrtype == AF_INET) && (host->h_length == 4)) {
+-               bcopy ((char *) *host->h_addr_list, (char *)&sin.sin_addr.s_addr, host->h_length);
++               memmove ((char *)&sin.sin_addr.s_addr, (char *) *host->h_addr_list, host->h_length);
+             } else
+                ArgusLog (LOG_ERR, "ArgusEstablishListen() unsupported bind address %s", bindIP);
+          } else
+@@ -600,7 +600,7 @@ ArgusCheckClientStatus (struct ArgusOutp
+             if (output->clientnum < ARGUS_MAXLISTEN) {
+                int i = output->clientnum++;
+ 
+-               bzero(&output->clients[i], sizeof(output->clients[i]));
++               memset(&output->clients[i], 0, sizeof(output->clients[i]));
+                output->clients[i].fd = fd;
+ #ifdef ARGUSDEBUG
+                ArgusDebug (2, "ArgusCheckClientStatus() new client %d\n", i);
+@@ -754,7 +754,7 @@ ArgusCheckClientMessage (struct ArgusOut
+          ArgusLog (LOG_ERR, "ArgusCheckClientMessage(0x%x, %d) sasl_getprop %s\n", client, fd, strerror(errno));
+ #endif /* ARGUS_SASL */
+ 
+-   bzero(buf, MAXSTRLEN);
++   memset(buf, 0, MAXSTRLEN);
+ 
+    if (value == 0)
+       value = MAXSTRLEN;
+@@ -791,8 +791,8 @@ ArgusCheckClientMessage (struct ArgusOut
+ #endif
+       if (outputlen > 0) {
+          if (outputlen < MAXSTRLEN) {
+-            bzero (buf, MAXSTRLEN);
+-            bcopy (outputbuf, buf, outputlen);
++            memset (buf, 0, MAXSTRLEN);
++            memmove (buf, outputbuf, outputlen);
+             cnt = outputlen;
+          } else
+             ArgusLog (LOG_ERR, "ArgusCheckClientMessage(0x%x, %d) sasl_decode returned %d bytes\n", client, fd, outputlen);
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusSource.c argus-3.0.0.rc.34/argus/ArgusSource.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusSource.c	2006-10-30 19:53:29.000000000 +0100
++++ argus-3.0.0.rc.34/argus/ArgusSource.c	2006-12-20 16:05:50.000000000 +0100
+@@ -92,11 +92,11 @@ ArgusInitSource (struct ArgusSourceStruc
+ 
+    src->ArgusInterfaces = 0;
+    for (i = 0; i < ARGUS_MAXINTERFACE; i++)
+-      bzero ((char *)&src->ArgusInterface[i], sizeof(struct ArgusInterfaceStruct));
++      memset ((char *)&src->ArgusInterface[i], 0, sizeof(struct ArgusInterfaceStruct));
+ 
+    if (src->ArgusRfileList != NULL) {
+       setuid(getuid());
+-      bzero(errbuf, sizeof(errbuf));
++      memset(errbuf, 0, sizeof(errbuf));
+ 
+       if (ArgusOpenInputPacketFile(src, errbuf) == 0) {
+       }
+@@ -156,7 +156,7 @@ ArgusInitSource (struct ArgusSourceStruc
+       src->ArgusInputFilter = cmdbuf;
+    }
+ 
+-   bzero ((char *) &src->ArgusInterface[0].ArgusFilter, sizeof (struct bpf_program));
++   memset ((char *) &src->ArgusInterface[0].ArgusFilter, 0, sizeof (struct bpf_program));
+ 
+    if (pcap_compile (src->ArgusInterface[0].ArgusPd, &src->ArgusInterface[0].ArgusFilter, src->ArgusInputFilter, getArgusOflag(src), src->ArgusInterface[0].ArgusNetMask) < 0)
+       ArgusLog (LOG_ERR, "%s\n", pcap_geterr (src->ArgusInterface[0].ArgusPd));
+@@ -421,7 +421,7 @@ ArgusMoatTshRead (struct ArgusSourceStru
+    int retn = 0, length = 0;
+    struct ip *iphdr = NULL;
+ 
+-   bzero (ArgusMoatPktHdr, sizeof(MoatTshBuffer));
++   memset (ArgusMoatPktHdr, 0, sizeof(MoatTshBuffer));
+  
+    if ((retn = read(pcap_fileno(src->ArgusInterface[0].ArgusPd), ArgusMoatPktHdr, ARGUSMOATLEN)) == ARGUSMOATLEN) {
+       ArgusMoatPktHdr->interface = 0;
+@@ -666,7 +666,7 @@ ArgusArcnetPacket (u_char *user, const s
+    caplen -= archdrlen;
+    p += archdrlen;
+    
+-   bcopy (p, (char *)ep, caplen);
++   memmove ((char *)ep, p, caplen);
+ 
+    src->ArgusModel->ArgusThisLength  = length;
+    src->ArgusModel->ArgusSnapLength  = caplen;
+@@ -973,8 +973,8 @@ Argusextract_fddi_addrs(const struct fdd
+          fsrc[i] = fddi_bit_swap[fp->fddi_shost[i]];
+    }
+    else {
+-      bcopy ((char *) fp->fddi_dhost, fdst, 6);
+-      bcopy ((char *) fp->fddi_shost, fsrc, 6);
++      memmove (fdst, (char *) fp->fddi_dhost, 6);
++      memmove (fsrc, (char *) fp->fddi_shost, 6);
+    }
+ }
+ 
+@@ -994,7 +994,7 @@ ArgusCreatePktFromFddi(const struct fddi
+          ((struct ether_header *) ep)->ether_type = EXTRACT_16BITS(&llc->ethertype[0]);
+          ptr = (unsigned char *)(llc + 1);
+          length -= (sizeof(struct fddi_header) + sizeof(struct llc));
+-         bcopy ((char *)ptr, (char *)(ep + 1), length);
++         memmove ((char *)(ep + 1), (char *)ptr, length);
+          retn = length + sizeof(struct ether_header);
+       }
+    }
+@@ -1099,7 +1099,7 @@ ArgusATMPacket(u_char *user, const struc
+    caplen -= ARGUS_ATM_HDR_OFFSET;
+    p += ARGUS_ATM_HDR_OFFSET;
+    
+-   bcopy (p, (char *)(ep + 1), caplen);
++   memmove ((char *)(ep + 1), p, caplen);
+ 
+    length += sizeof(*ep);
+    caplen += sizeof(*ep);
+@@ -1752,7 +1752,7 @@ ArgusGetInterfaceStatus (struct ArgusSou
+    if (strstr(device->name, "dag")) {
+       for (i = 0; i < src->ArgusInterfaces; i++) {
+          if (src->ArgusInterface[i].ArgusPd && (pcap_fileno(src->ArgusInterface[i].ArgusPd) > 0))
+-            bzero ((char *)&src->ArgusInterface[i].ifr, sizeof(ifr));
++            memset ((char *)&src->ArgusInterface[i].ifr, 0, sizeof(ifr));
+ 
+          src->ArgusInterface[i].ifr.ifr_flags |= IFF_UP;
+          setArgusInterfaceStatus(src, 1);
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusTcp.c argus-3.0.0.rc.34/argus/ArgusTcp.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusTcp.c	2006-10-30 19:07:13.000000000 +0100
++++ argus-3.0.0.rc.34/argus/ArgusTcp.c	2006-12-20 16:17:49.000000000 +0100
+@@ -89,7 +89,7 @@ ArgusUpdateTCPState (struct ArgusModeler
+          net->hdr.argus_dsrvl8.len  = ((sizeof(struct ArgusTCPObject)+3))/4 + 1;
+          flowstr->dsrs[ARGUS_NETWORK_INDEX] = (struct ArgusDSRHeader *) net;
+          tcpExt                    = &net->net_union.tcp;
+-         bzero ((char *)tcpExt, sizeof(*tcpExt));
++         memset ((char *)tcpExt, 0, sizeof(*tcpExt));
+ 
+          model->ArgusSnapLength -= tcphlen;
+          model->ArgusThisLength  = tcpdatalen;
+@@ -287,7 +287,7 @@ ArgusInitializeTCP (struct ArgusModelerS
+ {
+    struct ArgusTCPObject *tcpExt = (struct ArgusTCPObject *)&flow->canon.net.net_union.tcp;
+ 
+-   bzero ((char *)tcpExt, sizeof(*tcpExt));
++   memset ((char *)tcpExt, 0, sizeof(*tcpExt));
+ 
+    flow->qhdr.lasttime.tv_sec  = 0;
+    flow->qhdr.lasttime.tv_usec = 0;
+@@ -684,7 +684,7 @@ ArgusTCPFlowRecord (struct ArgusNetworkS
+          tcpExt->dst.ackbytes++;
+ 
+       if (tcp && ((length = argus->hdr.len) > 0)) {
+-         bcopy ((char *)tcp, &((char *)argus)[length], sizeof(*tcp));
++         memmove (&((char *)argus)[length], (char *)tcp, sizeof(*tcp));
+          argus->hdr.len += sizeof(*tcp);
+       }
+ 
+diff -rup argus-3.0.0.rc.34.orig/argus/ArgusUtil.c argus-3.0.0.rc.34/argus/ArgusUtil.c
+--- argus-3.0.0.rc.34.orig/argus/ArgusUtil.c	2006-11-03 18:44:23.000000000 +0100
++++ argus-3.0.0.rc.34/argus/ArgusUtil.c	2006-12-20 16:19:14.000000000 +0100
+@@ -854,8 +854,8 @@ ArgusZeroRecord (struct ArgusFlowStruct 
+ 
+             case ARGUS_JITTER_INDEX: {
+                struct ArgusJitterStruct *jit = (void *)flow->dsrs[i];
+-               bzero ((char *)&jit->act, sizeof(struct ArgusJitterObject));
+-               bzero ((char *)&jit->idle, sizeof(struct ArgusJitterObject));
++               memset ((char *)&jit->act, 0, sizeof(struct ArgusJitterObject));
++               memset ((char *)&jit->idle, 0, sizeof(struct ArgusJitterObject));
+                jit->act.src.minval  = 0xffffffff;
+                jit->idle.src.minval = 0xffffffff;
+                jit->act.dst.minval  = 0xffffffff;
+@@ -1105,7 +1105,7 @@ ArgusWriteSocket (struct ArgusOutputStru
+                   ArgusDebug (3, "ArgusHandleClientData: sasl_encode returned %d bytes\n", outputlen);
+ #endif
+                   if (outputlen < ARGUS_MAXRECORD) {
+-                     bcopy(output, asock->buf, outputlen);
++                     memmove(asock->buf, output, outputlen);
+                      cnt = outputlen;
+                   } else
+                      ArgusLog (LOG_ERR, "sasl_encode: returned too many bytes %d\n", outputlen);
+@@ -1282,7 +1282,7 @@ ArgusWriteOutSocket (struct ArgusOutputS
+                         ArgusDebug (3, "ArgusHandleClientData: sasl_encode returned %d bytes\n", outputlen);
+ #endif
+                         if (outputlen < ARGUS_MAXRECORD) {
+-                           bcopy(output, asock->buf, outputlen);
++                           memmove(asock->buf, output, outputlen);
+                            cnt = outputlen;
+ 
+                         } else
+diff -rup argus-3.0.0.rc.34.orig/argus/argus.c argus-3.0.0.rc.34/argus/argus.c
+--- argus-3.0.0.rc.34.orig/argus/argus.c	2006-11-03 19:54:13.000000000 +0100
++++ argus-3.0.0.rc.34/argus/argus.c	2006-12-20 16:12:47.000000000 +0100
+@@ -303,7 +303,7 @@ main (int argc, char *argv[])
+               if ((host = gethostbyname(optarg)) != NULL) {
+                  if ((host->h_addrtype == 2) && (host->h_length == 4)) {
+                     unsigned int addr;
+-                    bcopy ((char *) *host->h_addr_list, (char *)&addr, host->h_length);
++                    memmove ((char *)&addr, (char *) *host->h_addr_list, host->h_length);
+ #if defined(_LITTLE_ENDIAN)
+                     setArgusID (ArgusModel, ntohl(addr));
+ #else
+@@ -499,7 +499,7 @@ ArgusComplete ()
+    if (ArgusSourceTask->ArgusStartTime.tv_sec == 0)
+       ArgusSourceTask->ArgusStartTime = ArgusSourceTask->ArgusEndTime;
+ 
+-   bzero(buf, sizeof(buf));
++   memset(buf, 0, sizeof(buf));
+ 
+    timediff.tv_sec  = ArgusSourceTask->ArgusEndTime.tv_sec  - ArgusSourceTask->ArgusStartTime.tv_sec;
+    timediff.tv_usec = ArgusSourceTask->ArgusEndTime.tv_usec - ArgusSourceTask->ArgusStartTime.tv_usec;
+@@ -784,7 +784,7 @@ ArgusParseResourceFile (struct ArgusMode
+                               if ((host = gethostbyname(optarg)) != NULL) {
+                                  if ((host->h_addrtype == 2) && (host->h_length == 4)) {
+                                     unsigned int addr;
+-                                    bcopy ((char *) *host->h_addr_list, (char *)&addr, host->h_length);
++                                    memmove ((char *)&addr, (char *) *host->h_addr_list, host->h_length);
+ #if defined(_LITTLE_ENDIAN)
+                                     setArgusID (model, ntohl(addr));
+ #else
+diff -rup argus-3.0.0.rc.34.orig/common/argus_auth.c argus-3.0.0.rc.34/common/argus_auth.c
+--- argus-3.0.0.rc.34.orig/common/argus_auth.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/common/argus_auth.c	2006-12-20 16:56:47.000000000 +0100
+@@ -473,12 +473,12 @@ RaSendSaslString (FILE *f, const char *s
+    char saslbuf[MAXSTRLEN];
+    int len, al = 0;
+ 
+-   bzero (saslbuf, MAXSTRLEN);
++   memset (saslbuf, 0, MAXSTRLEN);
+    
+    snprintf(saslbuf, MAXSTRLEN, "{%d}\r\n", l);
+    len = strlen(saslbuf);
+ 
+-   bcopy (s, &saslbuf[len], l);
++   memmove (&saslbuf[len], s, l);
+    len += l;
+ 
+    al = fwrite(saslbuf, 1, len, f);
+diff -rup argus-3.0.0.rc.34.orig/common/argus_parse.c argus-3.0.0.rc.34/common/argus_parse.c
+--- argus-3.0.0.rc.34.orig/common/argus_parse.c	2006-08-18 19:15:14.000000000 +0200
++++ argus-3.0.0.rc.34/common/argus_parse.c	2006-12-20 16:56:34.000000000 +0100
+@@ -80,7 +80,7 @@ argus_parse_init (struct ARGUS_INPUT *in
+    if (input != NULL)
+       fd = input->fd;
+ 
+-   bzero((char *)&ArgusOutputFile, sizeof(ArgusOutputFile));
++   memset((char *)&ArgusOutputFile, 0, sizeof(ArgusOutputFile));
+ 
+    if (initCon) {
+       if (initCon->ahdr.status & ARGUS_DETAIL) detail++;
+@@ -496,8 +496,8 @@ main (int argc, char **argv)
+       *RaInputFilter = cmdbuf;
+    }
+ 
+-   bzero ((char *) &ArgusFilterCode, sizeof (ArgusFilterCode));
+-   bzero ((char *) &pbuf, sizeof (pbuf));
++   memset ((char *) &ArgusFilterCode, 0, sizeof (ArgusFilterCode));
++   memset ((char *) &pbuf, 0, sizeof (pbuf));
+ 
+    if (ArgusFilterCompile (&pbuf, &ArgusFilterCode, *RaInputFilter, 1, ArgusNetMask) < 0) {
+       if (pbuf.errbuf[0] != '\0') {
+@@ -574,7 +574,7 @@ main (int argc, char **argv)
+       } else {
+          struct ARGUS_INPUT addrbuf, *addr = &addrbuf;
+ 
+-         bzero ((char *) addr, sizeof (*addr));
++         memset ((char *) addr, 0, sizeof (*addr));
+          addr->fd = 0;
+ 
+          if (((ArgusReadConnection (addr, NULL)) >= 0)) {
+@@ -628,8 +628,8 @@ ArgusHandleDatum (struct ArgusRecord *pt
+       u_char buf[MAXSTRLEN];
+ 
+       totalrecords++;
+-      bcopy ((char *)ptr, (char *)ArgusOriginal, len);
+-      bcopy ((char *)ptr, (char *)&buf, len);
++      memmove ((char *)ArgusOriginal, (char *)ptr, len);
++      memmove ((char *)&buf, (char *)ptr, len);
+    
+       switch (ptr->ahdr.type) {
+          case ARGUS_MAR:
+@@ -736,68 +736,68 @@ ArgusGenerateCanonicalRecord (struct Arg
+ 
+    hdrs = ArgusThisFarHdrs;
+ 
+-   bzero ((char *)canon, sizeof(*canon));
++   memset ((char *)canon, 0, sizeof(*canon));
+ 
+    if (ptr->ahdr.type & ARGUS_MAR) {
+-      bcopy ((char *)ptr, (char *)canon, sizeof(*ptr));
++      memmove ((char *)canon, (char *)ptr, sizeof(*ptr));
+ 
+    } else {
+-      bcopy ((char *)&ptr->ahdr, (char *)&canon->ahdr, sizeof(canon->ahdr));
++      memmove ((char *)&canon->ahdr, (char *)&ptr->ahdr, sizeof(canon->ahdr));
+    
+       for (i = 1; i < 33; i++) {
+          index = 1 << (i - 1);
+          switch (index) {
+             case ARGUS_FAR_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_FAR_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_FAR_DSR_INDEX], (char *)&ar->argus_far, sizeof (ar->argus_far));
++                  memmove((char *)&ar->argus_far, (char *) hdrs[ARGUS_FAR_DSR_INDEX], sizeof (ar->argus_far));
+                break;
+             case ARGUS_MAC_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_MAC_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_MAC_DSR_INDEX], (char *)&canon->mac, sizeof(canon->mac));
++                  memmove((char *)&canon->mac, (char *) hdrs[ARGUS_MAC_DSR_INDEX], sizeof(canon->mac));
+                break;
+             case ARGUS_VLAN_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_VLAN_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_VLAN_DSR_INDEX], (char *)&canon->vlan, sizeof(canon->vlan));
++                  memmove((char *)&canon->vlan, (char *) hdrs[ARGUS_VLAN_DSR_INDEX], sizeof(canon->vlan));
+                break;
+             case ARGUS_MPLS_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_MPLS_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_MPLS_DSR_INDEX], (char *)&canon->mpls, sizeof(canon->mpls));
++                  memmove((char *)&canon->mpls, (char *) hdrs[ARGUS_MPLS_DSR_INDEX], sizeof(canon->mpls));
+                break;
+             case ARGUS_AGR_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_AGR_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_AGR_DSR_INDEX], (char *)&canon->agr, sizeof(canon->agr));
++                  memmove((char *)&canon->agr, (char *) hdrs[ARGUS_AGR_DSR_INDEX], sizeof(canon->agr));
+                break;
+             case ARGUS_TIME_DSR_STATUS:
+                if (ArgusThisFarStatus & ARGUS_TIME_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_TIME_DSR_INDEX], (char *)&canon->time, sizeof(canon->time));
++                  memmove((char *)&canon->time, (char *) hdrs[ARGUS_TIME_DSR_INDEX], sizeof(canon->time));
+                break;
+             case ARGUS_TCP_DSR_STATUS:   
+                if (ArgusThisFarStatus & ARGUS_TCP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_TCP_DSR_INDEX], (char *)&canon->acr_tcp, sizeof(canon->acr_tcp));
++                  memmove((char *)&canon->acr_tcp, (char *) hdrs[ARGUS_TCP_DSR_INDEX], sizeof(canon->acr_tcp));
+                break;
+             case ARGUS_ICMP_DSR_STATUS:  
+                if (ArgusThisFarStatus & ARGUS_ICMP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_ICMP_DSR_INDEX], (char *)&canon->acr_icmp, sizeof(canon->acr_icmp));
++                  memmove((char *)&canon->acr_icmp, (char *) hdrs[ARGUS_ICMP_DSR_INDEX], sizeof(canon->acr_icmp));
+                break;
+             case ARGUS_RTP_DSR_STATUS:   
+                if (ArgusThisFarStatus & ARGUS_RTP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_RTP_DSR_INDEX], (char *)&canon->acr_rtp, sizeof(canon->acr_rtp));
++                  memmove((char *)&canon->acr_rtp, (char *) hdrs[ARGUS_RTP_DSR_INDEX], sizeof(canon->acr_rtp));
+                break;
+             case ARGUS_IGMP_DSR_STATUS:  
+                if (ArgusThisFarStatus & ARGUS_IGMP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_IGMP_DSR_INDEX], (char *)&canon->acr_igmp, sizeof(canon->acr_igmp));
++                  memmove((char *)&canon->acr_igmp, (char *) hdrs[ARGUS_IGMP_DSR_INDEX], sizeof(canon->acr_igmp));
+                break;
+             case ARGUS_ARP_DSR_STATUS:   
+                if (ArgusThisFarStatus & ARGUS_ARP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_ARP_DSR_INDEX], (char *)&canon->acr_arp, sizeof(canon->acr_arp));
++                  memmove((char *)&canon->acr_arp, (char *) hdrs[ARGUS_ARP_DSR_INDEX], sizeof(canon->acr_arp));
+                break;
+             case ARGUS_FRG_DSR_STATUS:   
+                if (ArgusThisFarStatus & ARGUS_FRG_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_FRG_DSR_INDEX], (char *)&canon->acr_frag, sizeof(canon->acr_frag));
++                  memmove((char *)&canon->acr_frag, (char *) hdrs[ARGUS_FRG_DSR_INDEX], sizeof(canon->acr_frag));
+                break;
+             case ARGUS_ESP_DSR_STATUS:   
+                if (ArgusThisFarStatus & ARGUS_ESP_DSR_STATUS)
+-                  bcopy((char *) hdrs[ARGUS_ESP_DSR_INDEX], (char *)&canon->acr_esp, sizeof(canon->acr_esp));
++                  memmove((char *)&canon->acr_esp, (char *) hdrs[ARGUS_ESP_DSR_INDEX], sizeof(canon->acr_esp));
+                break;
+          }
+       }
+@@ -829,7 +829,7 @@ ArgusParseCiscoRecordV1 (u_char **ptr)
+    struct ArgusRecord *argus = ArgusNetFlowArgusRecord;
+    struct ArgusMacStruct mac;
+ 
+-   bzero ((char *) argus, sizeof (*argus));
++   memset ((char *) argus, 0, sizeof (*argus));
+    argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+    argus->ahdr.cause   = ARGUS_STATUS;
+    argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -868,7 +868,7 @@ ArgusParseCiscoRecordV1 (u_char **ptr)
+       case IPPROTO_TCP: { 
+          struct ArgusTCPObject tcpbuf, *tcp = &tcpbuf;
+ 
+-         bzero ((char *) tcp, sizeof(*tcp));
++         memset ((char *) tcp, 0, sizeof(*tcp));
+          tcp->type = ARGUS_TCP_DSR;
+          tcp->length = sizeof(struct ArgusTCPObject);
+          tcp->src.flags    = entryPtrV1->flags;
+@@ -888,7 +888,7 @@ ArgusParseCiscoRecordV1 (u_char **ptr)
+                break;
+          }
+ 
+-         bcopy ((char *)tcp, &((char *)argus)[argus->ahdr.length], sizeof(*tcp));
++         memmove (&((char *)argus)[argus->ahdr.length], (char *)tcp, sizeof(*tcp));
+          argus->ahdr.length += sizeof(*tcp);
+       }
+ 
+@@ -906,17 +906,17 @@ ArgusParseCiscoRecordV1 (u_char **ptr)
+       break;
+    }
+ 
+-   bzero ((char *)&mac, sizeof (mac));
++   memset ((char *)&mac, 0, sizeof (mac));
+    mac.type   = ARGUS_MAC_DSR;
+    mac.length = sizeof(mac);
+    mac.status = 0;
+    entryPtrV1->input = ntohs(entryPtrV1->input);
+    entryPtrV1->output = ntohs(entryPtrV1->output);
+    
+-   bcopy((char *)&entryPtrV1->input, (char *)&mac.phys_union.ether.ethersrc[4], 2);
+-   bcopy((char *)&entryPtrV1->output,(char *)&mac.phys_union.ether.etherdst[4], 2);
++   memmove((char *)&mac.phys_union.ether.ethersrc[4], (char *)&entryPtrV1->input, 2);
++   memmove((char *)&mac.phys_union.ether.etherdst[4], (char *)&entryPtrV1->output, 2);
+ 
+-   bcopy ((char *)&mac, &((char *)argus)[argus->ahdr.length], sizeof(mac));
++   memmove (&((char *)argus)[argus->ahdr.length], (char *)&mac, sizeof(mac));
+    argus->ahdr.length += sizeof(mac);
+ 
+ #ifdef _LITTLE_ENDIAN
+@@ -939,7 +939,7 @@ ArgusParseCiscoRecordV5 (u_char **ptr)
+    struct ArgusRecord *argus = ArgusNetFlowArgusRecord;
+    struct ArgusMacStruct mac;
+ 
+-   bzero ((char *) argus, sizeof (*argus));
++   memset ((char *) argus, 0, sizeof (*argus));
+    argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+    argus->ahdr.cause   = ARGUS_STATUS;
+    argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -980,7 +980,7 @@ ArgusParseCiscoRecordV5 (u_char **ptr)
+       case IPPROTO_TCP: {
+          struct ArgusTCPObject tcpbuf, *tcp = &tcpbuf;
+ 
+-         bzero ((char *) tcp, sizeof(*tcp));
++         memset ((char *) tcp, 0, sizeof(*tcp));
+          tcp->type = ARGUS_TCP_DSR;
+          tcp->length = sizeof(struct ArgusTCPObject);
+          tcp->src.flags    = entryPtrV5->tcp_flags;
+@@ -1000,23 +1000,23 @@ ArgusParseCiscoRecordV5 (u_char **ptr)
+                break;
+          }
+ 
+-         bcopy ((char *)tcp, &((char *)argus)[argus->ahdr.length], sizeof(*tcp));
++         memmove (&((char *)argus)[argus->ahdr.length], (char *)tcp, sizeof(*tcp));
+          argus->ahdr.length += sizeof(*tcp);
+       }
+       break;
+    }
+ 
+-   bzero ((char *)&mac, sizeof (mac));
++   memset ((char *)&mac, 0, sizeof (mac));
+    mac.type   = ARGUS_MAC_DSR;
+    mac.length = sizeof(mac);
+    mac.status = 0;
+    entryPtrV5->input = ntohs(entryPtrV5->input);
+    entryPtrV5->output = ntohs(entryPtrV5->output);
+ 
+-   bcopy((char *)&entryPtrV5->input, (char *)&mac.phys_union.ether.ethersrc[4], 2);
+-   bcopy((char *)&entryPtrV5->output,(char *)&mac.phys_union.ether.etherdst[4], 2);
++   memmve((char *)&mac.phys_union.ether.ethersrc[4], (char *)&entryPtrV5->input, 2);
++   memmove((char *)&mac.phys_union.ether.etherdst[4], (char *)&entryPtrV5->output, 2);
+ 
+-   bcopy ((char *)&mac, &((char *)argus)[argus->ahdr.length], sizeof(mac));
++   memmove (&((char *)argus)[argus->ahdr.length], (char *)&mac, sizeof(mac));
+    argus->ahdr.length += sizeof(mac);
+ 
+ #ifdef _LITTLE_ENDIAN
+@@ -1039,7 +1039,7 @@ ArgusParseCiscoRecordV6 (u_char **ptr)
+    struct ArgusRecord *argus = ArgusNetFlowArgusRecord;
+    struct ArgusMacStruct mac;
+ 
+-   bzero ((char *) argus, sizeof (*argus));
++   memset ((char *) argus, 0, sizeof (*argus));
+    argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+    argus->ahdr.cause   = ARGUS_STATUS;
+    argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -1080,7 +1080,7 @@ ArgusParseCiscoRecordV6 (u_char **ptr)
+       case IPPROTO_TCP: {
+          struct ArgusTCPObject tcpbuf, *tcp = &tcpbuf;
+ 
+-         bzero ((char *) tcp, sizeof(*tcp));
++         memset ((char *) tcp, 0, sizeof(*tcp));
+          tcp->type = ARGUS_TCP_DSR;
+          tcp->length = sizeof(struct ArgusTCPObject);
+          tcp->src.flags    = entryPtrV6->tcp_flags;
+@@ -1100,23 +1100,23 @@ ArgusParseCiscoRecordV6 (u_char **ptr)
+                break;
+          }
+ 
+-         bcopy ((char *)tcp, &((char *)argus)[argus->ahdr.length], sizeof(*tcp));
++         memmve (&((char *)argus)[argus->ahdr.length], (char *)tcp, sizeof(*tcp));
+          argus->ahdr.length += sizeof(*tcp);
+       }
+       break;
+    }
+ 
+-   bzero ((char *)&mac, sizeof (mac));
++   memset ((char *)&mac, 0, sizeof (mac));
+    mac.type   = ARGUS_MAC_DSR;
+    mac.length = sizeof(mac);
+    mac.status = 0;
+    entryPtrV6->input = ntohs(entryPtrV6->input);
+    entryPtrV6->output = ntohs(entryPtrV6->output);
+ 
+-   bcopy((char *)&entryPtrV6->input, (char *)&mac.phys_union.ether.ethersrc[4], 2);
+-   bcopy((char *)&entryPtrV6->output,(char *)&mac.phys_union.ether.etherdst[4], 2);
++   memmove((char *)&mac.phys_union.ether.ethersrc[4], (char *)&entryPtrV6->input, 2);
++   memmove((char *)&mac.phys_union.ether.etherdst[4], (char *)&entryPtrV6->output, 2);
+ 
+-   bcopy ((char *)&mac, &((char *)argus)[argus->ahdr.length], sizeof(mac));
++   memmove (&((char *)argus)[argus->ahdr.length], (char *)&mac, sizeof(mac));
+    argus->ahdr.length += sizeof(mac);
+ 
+ #ifdef _LITTLE_ENDIAN
+@@ -1145,7 +1145,7 @@ ArgusParseCiscoRecord (u_char **ptr)
+          CiscoFlowHeaderV1_t *hdrPtrV1   = (CiscoFlowHeaderV1_t *) *ptr;
+          CiscoFlowEntryV1_t  *entryPtrV1 = (CiscoFlowEntryV1_t *) (hdrPtrV1 + 1);
+ 
+-         bzero ((char *) argus, sizeof (*argus));
++         memset ((char *) argus, 0, sizeof (*argus));
+          argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+          argus->ahdr.cause   = ARGUS_STATUS;
+          argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -1191,7 +1191,7 @@ ArgusParseCiscoRecord (u_char **ptr)
+          CiscoFlowHeaderV5_t *hdrPtrV5   = (CiscoFlowHeaderV5_t *) ptr;
+          CiscoFlowEntryV5_t  *entryPtrV5 = (CiscoFlowEntryV5_t *) (hdrPtrV5 + 1);
+ 
+-         bzero ((char *) argus, sizeof (*argus));
++         memset ((char *) argus, 0, sizeof (*argus));
+          argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+          argus->ahdr.cause   = ARGUS_STATUS;
+          argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -1238,7 +1238,7 @@ ArgusParseCiscoRecord (u_char **ptr)
+          CiscoFlowHeaderV6_t *hdrPtrV6   = (CiscoFlowHeaderV6_t *) ptr;
+          CiscoFlowEntryV6_t  *entryPtrV6 = (CiscoFlowEntryV6_t *) (hdrPtrV6 + 1);
+ 
+-         bzero ((char *) argus, sizeof (*argus));
++         memset ((char *) argus, 0, sizeof (*argus));
+          argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+          argus->ahdr.cause   = ARGUS_STATUS;
+          argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -1301,7 +1301,7 @@ ArgusNetFlowCallRecord (u_char **ptr)
+    BinaryRecord_CallRecord_V1 *call = (BinaryRecord_CallRecord_V1 *) *ptr;
+ 
+    if (*ptr) {
+-      bzero ((char *) argus, sizeof (*argus));
++      memset ((char *) argus, 0, sizeof (*argus));
+       argus->ahdr.type    = ARGUS_FAR | ARGUS_CISCO_NETFLOW;
+       argus->ahdr.cause   = ARGUS_STATUS;
+       argus->ahdr.length  = sizeof(argus->ahdr) + sizeof(argus->argus_far);
+@@ -1348,7 +1348,7 @@ ArgusNetFlowDetailInt (u_char **ptr)
+ 
+    if (*ptr) {
+       dint = NULL;
+-      bzero ((char *) argus, sizeof (*argus));
++      memset ((char *) argus, 0, sizeof (*argus));
+    }
+ 
+ 
+@@ -1438,7 +1438,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+ 
+    if (fd >= 0) {
+       if (!(Cflag)) {
+-         bzero ((char *) &argus, sizeof(argus));
++         memset ((char *) &argus, 0, sizeof(argus));
+          if ((cnt = read (fd, &argus, sizeof(argus.ahdr))) == sizeof(argus.ahdr)) {
+ #ifdef ARGUSDEBUG
+             ArgusDebug (5, "ArgusReadConnection() read %d bytes\n", cnt);
+@@ -1447,7 +1447,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                if (((ptr[0] == 0x1F) && ((ptr[1] == 0x8B) || (ptr[1] == 0x9D))) ||
+                    ((ptr[0] == 'B') && (ptr[1] == 'Z') && (ptr[2] == 'h'))) {
+                   char cmd[256];
+-                  bzero(cmd, 256);
++                  memset(cmd, 0, 256);
+                   close(fd);
+                   if (ptr[0] == 'B')
+                      strcpy(cmd, "bzip2 -dc ");
+@@ -1514,8 +1514,8 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                         return (-1);
+                      }
+       
+-                     bcopy ((char *) &argus, (char *)&input->ArgusInitCon, sizeof (argus));
+-                     bcopy ((char *) &argus, (char *) ArgusOriginal, length);
++                     memmove ((char *)&input->ArgusInitCon, (char *) &argus, sizeof (argus));
++                     memmove ((char *) ArgusOriginal, (char *) &argus, length);
+                      ArgusInput = input;
+       
+                      ArgusHandleDatum ((struct ArgusRecord *)&argus, &ArgusFilterCode);
+@@ -1524,7 +1524,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                      ArgusNtoH(&argus);
+ #endif
+       
+-                     bcopy ((char *) &argus, (char *)&input->ArgusManStart, sizeof (argus));
++                     memmove ((char *)&input->ArgusManStart, (char *) &argus, sizeof (argus));
+                      input->major_version = MAJOR_VERSION_2;
+                      input->minor_version = MINOR_VERSION_0;
+                      input->ArgusReadSize = argus.argus_mar.record_len;
+@@ -1543,7 +1543,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                         if ((ArgusRemoteFilter != NULL) && (filename == NULL) && (fd != 0)) {
+                            int len;
+ 
+-                           bzero(buf, MAXSTRLEN);
++                           memset(buf, 0, MAXSTRLEN);
+                            snprintf ((char *) buf, MAXSTRLEN-1, "FILTER: man or %s", (char *) ArgusRemoteFilter);
+                            len = strlen((char *) buf);
+                            if (ArgusWriteConnection (input, buf, len) < 0) {
+@@ -1564,7 +1564,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                   char *ptr;
+                   int size;
+    
+-                  bcopy ((char *)&argus, buf, sizeof(argus.ahdr));
++                  memmove (buf, (char *)&argus, sizeof(argus.ahdr));
+ 
+                   size = sizeof(*ws) - sizeof(argus.ahdr);
+    
+@@ -1584,11 +1584,11 @@ ArgusReadConnection (struct ARGUS_INPUT 
+ 
+                      if (initCon == NULL) {
+                         if ((initCon = (struct ArgusRecord *) calloc (1, sizeof (argus))) != NULL)
+-                           bcopy ((char *) &argus, (char *) initCon, sizeof (argus));
++                           memmove ((char *) initCon, (char *) &argus, sizeof (argus));
+                      }
+ 
+-                     bcopy ((char *) &argus, (char *)&input->ArgusInitCon, sizeof (argus));
+-                     bcopy ((char *)&argus, (char *) ArgusOriginal, sizeof(argus));
++                     memmove ((char *)&input->ArgusInitCon, (char *) &argus, sizeof (argus));
++                     memmove ((char *) ArgusOriginal, (char *)&argus, sizeof(argus));
+ 
+                      ArgusInput = input;
+ 
+@@ -1617,7 +1617,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                   BinaryHeaderF2 *ArgusNetFlow = (BinaryHeaderF2 *) buf;
+                   int size;
+    
+-                  bcopy ((char *)&argus, buf, sizeof(argus.ahdr));
++                  memmove (buf, (char *)&argus, sizeof(argus.ahdr));
+                   size = sizeof(*ArgusNetFlow) - sizeof(argus.ahdr);
+    
+                   if ((cnt = read (fd, &buf[sizeof(argus.ahdr)], size)) != size) {
+@@ -1633,7 +1633,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+                      ArgusNetFlow->missed    = ntohl(ArgusNetFlow->missed);
+                      ArgusNetFlow->records   = ntohl(ArgusNetFlow->records);
+ #endif
+-                     bzero ((char *)&argus, sizeof(argus));
++                     memset ((char *)&argus, 0, sizeof(argus));
+    
+                      argus.ahdr.type                 = ARGUS_MAR | ARGUS_CISCO_NETFLOW;
+                      argus.ahdr.length               = sizeof (argus);
+@@ -1657,11 +1657,11 @@ ArgusReadConnection (struct ARGUS_INPUT 
+ #endif
+                         if (initCon == NULL) {
+                            if ((initCon = (struct ArgusRecord *) calloc (1, sizeof (argus))) != NULL)
+-                              bcopy ((char *) &argus, (char *) initCon, sizeof (argus));
++                              memmove ((char *) initCon, (char *) &argus, sizeof (argus));
+                         }
+ 
+-                        bcopy ((char *) &argus, (char *)&input->ArgusInitCon, sizeof (argus));
+-                        bcopy ((char *) &argus, (char *) ArgusOriginal, sizeof(argus));
++                        memmove ((char *)&input->ArgusInitCon, (char *) &argus, sizeof (argus));
++                        memmove ((char *) ArgusOriginal, (char *) &argus, sizeof(argus));
+                         ArgusInput = input;
+ 
+                         ArgusGenerateCanonicalRecord (&argus, canon);
+@@ -1702,7 +1702,7 @@ ArgusReadConnection (struct ARGUS_INPUT 
+ #ifdef ARGUSDEBUG
+             ArgusDebug (2, "ArgusReadConnection(0x%x) reading from Cisco Router.\n", input);
+ #endif
+-            bzero ((char *)&argus, sizeof(argus));
++            memset ((char *)&argus, 0, sizeof(argus));
+             argus_parse_init (input);
+          }
+       }
+@@ -1902,7 +1902,7 @@ ArgusReadSaslStreamSocket (struct ARGUS_
+ 
+                while ((char *)argus < end) {
+                   input->ArgusReadSocketCnt = ntohs(argus->ahdr.length);
+-                  bcopy (argus, input->ArgusReadBuffer, input->ArgusReadSocketCnt);
++                  memmove (input->ArgusReadBuffer, argus, input->ArgusReadSocketCnt);
+ 
+                   if (ArgusHandleDatum (argus, &ArgusFilterCode) == 1) {
+                      if (!input->filename)
+@@ -1970,7 +1970,7 @@ ArgusReadStreamSocket (struct ARGUS_INPU
+          if (input->ArgusReadSocketState == ARGUS_READINGHDR) {
+             input->ArgusReadSocketState = ARGUS_READINGBLOCK;
+             
+-            bcopy ((char *) &((struct ArgusRecordHeader *)input->ArgusReadPtr)->length, (char *) &length, sizeof(length));
++            memmove ((char *) &length, (char *) &((struct ArgusRecordHeader *)input->ArgusReadPtr)->length, sizeof(length));
+             input->ArgusReadSocketSize = ntohs(length) - sizeof(struct ArgusRecordHeader);
+             if ((input->ArgusReadSocketSize > 0) && (input->ArgusReadSocketSize < MAXSTRLEN)) {
+                input->ArgusReadPtr = &input->ArgusReadBuffer[input->ArgusReadSocketCnt];
+@@ -1986,7 +1986,7 @@ ArgusReadStreamSocket (struct ARGUS_INPU
+             if (input->major_version < 2) {
+                ArgusConvertWriteStruct ((struct WriteStruct *)input->ArgusReadBuffer,
+                                         (struct ArgusRecord *)input->ArgusConvBuffer);
+-               bcopy ((char *) input->ArgusConvBuffer, input->ArgusReadBuffer, MAXSTRLEN);
++               memmove (input->ArgusReadBuffer, (char *) input->ArgusConvBuffer, MAXSTRLEN);
+             }
+ 
+             if (ArgusHandleDatum ((struct ArgusRecord *)input->ArgusReadBuffer, &ArgusFilterCode) == 1) {
+@@ -2002,7 +2002,7 @@ ArgusReadStreamSocket (struct ARGUS_INPU
+             }
+ 
+             input->ArgusReadPtr = input->ArgusReadBuffer;
+-            bzero (input->ArgusReadBuffer, MAXSTRLEN);
++            memset (input->ArgusReadBuffer, 0, MAXSTRLEN);
+             input->ArgusReadSocketCnt = 0;
+          }
+       }
+@@ -2105,7 +2105,7 @@ ArgusReadCiscoStreamSocket (struct ARGUS
+ 
+                if (!(input->ArgusReadSocketNum--)) {
+                   input->ArgusReadPtr = input->ArgusReadBuffer;
+-                  bzero (input->ArgusReadBuffer, MAXSTRLEN);
++                  memset (input->ArgusReadBuffer, 0, MAXSTRLEN);
+ 
+                } else {
+                   input->ArgusReadPtr = input->ArgusReadBlockPtr;
+@@ -2279,7 +2279,7 @@ ArgusReadStream ()
+       return;
+    }
+ 
+-   bzero ((char *)&timeoutValue, sizeof(timeoutValue));
++   memset ((char *)&timeoutValue, 0, sizeof(timeoutValue));
+ 
+    if (gettimeofday (&now, NULL) == 0) {
+       ArgusAdjustGlobalTime(&ArgusGlobalTime, &ArgusNowTime);
+@@ -2535,7 +2535,7 @@ ArgusGetServerSocket (struct ARGUS_INPUT
+          } else
+             portnum = htons(input->portnum);
+ 
+-         bzero ((char *)&argus, sizeof(argus));
++         memset ((char *)&argus, 0, sizeof(argus));
+          argus.ahdr.type                 = ARGUS_MAR | ARGUS_CISCO_NETFLOW;
+          argus.ahdr.length               = sizeof (argus);
+          argus.ahdr.cause                = ARGUS_START;
+@@ -2549,15 +2549,15 @@ ArgusGetServerSocket (struct ARGUS_INPUT
+          input->major_version = argus.argus_mar.major_version;
+          input->minor_version = argus.argus_mar.minor_version;
+ 
+-         bcopy ((char *) &argus, (char *)&input->ArgusInitCon, sizeof (argus));
+-         bcopy ((char *) &argus, (char *) ArgusOriginal, sizeof(argus));
++         memmove ((char *)&input->ArgusInitCon, (char *) &argus, sizeof (argus));
++         memmove ((char *) ArgusOriginal, (char *) &argus, sizeof(argus));
+          ArgusInput = input;
+ 
+       } else
+          ArgusLog (LOG_ERR, "ArgusGetServerSocket(0x%x) unknown type\n", input);
+    }
+ 
+-   bzero ((char *) &server, sizeof (server));
++   memset ((char *) &server, 0, sizeof (server));
+ 
+    if ((s = socket (AF_INET, type, 0)) >= 0) {
+       if (type == SOCK_DGRAM) {
+@@ -2582,7 +2582,7 @@ ArgusGetServerSocket (struct ARGUS_INPUT
+ 
+          if ((hp = gethostbyaddr ((char *)&input->addr, sizeof (input->addr), AF_INET)) != NULL) {
+             input->hostname = strdup(hp->h_name);
+-            bcopy ((char *) hp->h_addr, (char *)&server.sin_addr, hp->h_length);
++            memmove ((char *)&server.sin_addr, (char *) hp->h_addr, hp->h_length);
+             server.sin_family = hp->h_addrtype;
+             server.sin_port = portnum;
+ #ifdef ARGUSDEBUG
+@@ -2889,7 +2889,7 @@ check_time (struct ArgusRecord *ptr)
+       if (!explicit_date) {
+          tm = localtime_r((time_t *)&start->tv_sec, &tmbuf);
+          if (tm->tm_yday != starTimeFilter.tm_yday) {
+-            bcopy ((char *) tm, (char *) &tmbuf, sizeof (struct tm));
++            memmove ((char *) &tmbuf, (char *) tm, sizeof (struct tm));
+             if (check_time_format (&tmbuf, timearg))
+                ArgusLog (LOG_ERR, "time syntax error %s\n", timearg);
+          }
+@@ -2926,7 +2926,7 @@ parseUserDataArg (char **arg, char *args
+    int retn = -1;
+    char buf[64], *ptr = buf;
+    
+-   bzero (buf, 64);
++   memset (buf, 0, 64);
+    strcpy (buf, *arg);
+    ptr += strlen (buf);
+ 
+@@ -2992,7 +2992,7 @@ parseTimeArg ( char **arg, char *args[],
+    int retn = -1;
+    char buf[64], *ptr = buf;
+ 
+-   bzero (buf, 64);
++   memset (buf, 0, 64);
+    strcpy (buf, *arg);
+    ptr += strlen (buf);
+    if ((ptr = strchr(*arg, '-')) && (*(ptr + 1) != '\0')) {
+@@ -3054,7 +3054,7 @@ check_time_format (struct tm *tm, char *
+ 
+    } else {
+       if ((retn = parseTime (&starTimeFilter, tm, buf)) > 0) {
+-         bcopy ((char *)&starTimeFilter, (char *)&lastTimeFilter, sizeof(struct tm));
++         memmove ((char *)&lastTimeFilter, (char *)&starTimeFilter, sizeof(struct tm));
+          switch (retn) {
+             case ARGUS_YEAR:  lastTimeFilter.tm_year++; break;
+             case ARGUS_MONTH: lastTimeFilter.tm_mon++; break;
+@@ -3091,7 +3091,7 @@ parseTime (struct tm *tm, struct tm *ctm
+ 
+    /*[[[yyyy/]mm/]dd].]hh[:mm[:ss]]*/
+ 
+-   bcopy ((u_char *) ctm, (u_char *) tm, sizeof (struct tm));
++   memmove ((u_char *) tm, (u_char *) ctm, sizeof (struct tm));
+ 
+    if ((hptr = strchr (str, '.')) != NULL) {
+       *hptr++ = '\0';
+diff -rup argus-3.0.0.rc.34.orig/common/argus_util.c argus-3.0.0.rc.34/common/argus_util.c
+--- argus-3.0.0.rc.34.orig/common/argus_util.c	2006-10-02 17:23:44.000000000 +0200
++++ argus-3.0.0.rc.34/common/argus_util.c	2006-12-20 17:02:40.000000000 +0100
+@@ -540,12 +540,12 @@ ArgusNtoH (struct ArgusRecord *argus)
+                   u_int32_t value;
+                   stat->n        = ntohl(stat->n);
+                   stat->minval   = ntohl(stat->minval);
+-                  bcopy((char *)&stat->meanval, (char *)&value, sizeof(value));
++                  memmove((char *)&value, (char *)&stat->meanval, sizeof(value));
+                   value          = ntohl(value);
+-                  bcopy((char *)&value, (char *)&stat->meanval, sizeof(value));
+-                  bcopy((char *)&stat->stdev, (char *)&value, sizeof(value));
++                  memmove((char *)&stat->meanval, (char *)&value, sizeof(value));
++                  memmove((char *)&value, (char *)&stat->stdev, sizeof(value));
+                   value          = ntohl(value);
+-                  bcopy((char *)&value, (char *)&stat->stdev, sizeof(value));
++                  memmove((char *)&stat->stdev, (char *)&value, sizeof(value));
+                   stat->maxval   = ntohl(stat->maxval);
+ 
+                   stat++;
+@@ -946,12 +946,12 @@ ArgusHtoN (struct ArgusRecord *argus)
+                   u_int32_t value;
+                   stat->n        = htonl(stat->n);
+                   stat->minval   = htonl(stat->minval);
+-                  bcopy((char *)&stat->meanval, (char *)&value, sizeof(value));
++                  memmove((char *)&value, (char *)&stat->meanval, sizeof(value));
+                   value          = htonl(value);
+-                  bcopy((char *)&value, (char *)&stat->meanval, sizeof(value));
+-                  bcopy((char *)&stat->stdev, (char *)&value, sizeof(value));
++                  memmove((char *)&stat->meanval, (char *)&value, sizeof(value));
++                  memmove((char *)&value, (char *)&stat->stdev, sizeof(value));
+                   value          = htonl(value);
+-                  bcopy((char *)&value, (char *)&stat->stdev, sizeof(value));
++                  memmove((char *)&stat->stdev, (char *)&value, sizeof(value));
+                   stat->maxval   = htonl(stat->maxval);
+                   stat++;
+                   len -= sizeof (*stat);
+@@ -1535,8 +1535,8 @@ print_time(struct timeval *tvp)
+    char *retn = ArgusPrintTimeBuf, *ptr;
+    struct tm *tm, tmbuf;
+ 
+-   bzero (timeZoneBuf, sizeof(timeZoneBuf));
+-   bzero (ArgusPrintTimeBuf, sizeof(ArgusPrintTimeBuf));
++   memset (timeZoneBuf, 0, sizeof(timeZoneBuf));
++   memset (ArgusPrintTimeBuf, 0, sizeof(ArgusPrintTimeBuf));
+ 
+    if ((tm = localtime_r ((time_t *)&tvp->tv_sec, &tmbuf)) != NULL) {
+       if (uflag)
+@@ -1614,8 +1614,8 @@ lookup_nsap(struct ArgusParserStruct *pa
+           tp->e_addr1 == j &&
+           tp->e_addr2 == k &&
+           tp->e_nsap[0] == nlen &&
+-          bcmp((char *)&(nsap[1]),
+-         (char *)&(tp->e_nsap[1]), nlen) == 0)
++          ( nlen == 0 ? 0 : memcmp((char *)&(nsap[1]),
++         (char *)&(tp->e_nsap[1]), nlen) == 0))
+          return tp;
+       else
+          tp = tp->e_nxt;
+@@ -1623,7 +1623,7 @@ lookup_nsap(struct ArgusParserStruct *pa
+    tp->e_addr1 = j;
+    tp->e_addr2 = k;
+    tp->e_nsap = (u_char *) calloc(1, nlen + 1);
+-   bcopy(nsap, tp->e_nsap, nlen + 1);
++   memmove(tp->e_nsap, nsap, nlen + 1);
+    tp->e_nxt = (struct enamemem *)calloc(1, sizeof(*tp));
+ 
+    return tp;
+@@ -1696,7 +1696,7 @@ ArgusInitEprotoarray(struct ArgusParserS
+ {
+    struct ArgusEtherTypeStruct *p = argus_ethertype_names;
+ 
+-   bzero ((char *)parser->argus_eproto_db, sizeof (parser->argus_eproto_db));
++   memset ((char *)parser->argus_eproto_db, 0, sizeof (parser->argus_eproto_db));
+ 
+    while (p->range != NULL) {
+       int i, start, end;
+@@ -2209,7 +2209,7 @@ etheraddr_string(u_char *ep)
+    char *cp = etheraddrbuf;
+    u_int i, j;
+ 
+-   bzero (cp, sizeof(etheraddrbuf));
++   memset (cp, 0, sizeof(etheraddrbuf));
+    if ((j = *ep >> 4) != 0)
+       *cp++ = hex[j];
+    *cp++ = hex[*ep++ & 0xf];
diff --git a/package/argus/argus.mk b/package/argus/argus.mk
new file mode 100644
index 000000000..757adc28f
--- /dev/null
+++ b/package/argus/argus.mk
@@ -0,0 +1,92 @@
+#############################################################
+#
+# argus
+#
+#############################################################
+ARGUS_VER:=3.0.0.rc.34
+ARGUS_SOURCE:=argus_$(ARGUS_VER).orig.tar.gz
+ARGUS_PATCH:=argus_$(ARGUS_VER)-1.diff.gz
+ARGUS_SITE:=ftp://ftp.debian.org/debian/pool/main/a/argus/
+ARGUS_DIR:=$(BUILD_DIR)/argus-$(ARGUS_VER)
+ARGUS_CAT:=$(ZCAT)
+ARGUS_BINARY:=bin/argus
+ARGUS_TARGET_BINARY:=usr/sbin/argus
+
+ARGUS_CONFIG_OPTS:=
+ifneq ($(strip $(BR2_LARGEFILE)),y)
+ARGUS_CONFIG_OPTS += --disable-largefile
+endif
+
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=yes
+ifeq ($(BR2_i386),y)
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=no
+endif
+ifeq ($(BR2_x86_64),y)
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=no
+endif
+ifeq ($(BR2_m68k),y)
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=no
+endif
+ifeq ($(BR2_s390),y)
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=no
+endif
+ifeq ($(BR2_powerpc)$(BR2_ENDIAN),yBIG)
+ARGUS_TRAP_CHECK=ac_cv_lbl_unaligned_fail=no
+endif
+
+$(DL_DIR)/$(ARGUS_SOURCE):
+	$(WGET) -P $(DL_DIR) $(ARGUS_SITE)/$(ARGUS_SOURCE)
+
+$(DL_DIR)/$(ARGUS_PATCH):
+	$(WGET) -P $(DL_DIR) $(ARGUS_SITE)/$(ARGUS_PATCH)
+
+argus-source: $(DL_DIR)/$(ARGUS_SOURCE) $(DL_DIR)/$(ARGUS_PATCH)
+
+$(ARGUS_DIR)/.unpacked: $(DL_DIR)/$(ARGUS_SOURCE) $(DL_DIR)/$(ARGUS_PATCH)
+	$(ARGUS_CAT) $(DL_DIR)/$(ARGUS_SOURCE) | tar -C $(BUILD_DIR) $(TAR_OPTIONS) -
+	toolchain/patch-kernel.sh $(ARGUS_DIR) package/argus/ argus\*.patch
+ifneq ($(ARGUS_PATCH),)
+	(cd $(ARGUS_DIR) && $(ARGUS_CAT) $(DL_DIR)/$(ARGUS_PATCH) | patch -p1)
+	if [ -d $(ARGUS_DIR)/debian/patches ]; then \
+		toolchain/patch-kernel.sh $(ARGUS_DIR) $(ARGUS_DIR)/debian/patches \*.patch ; \
+	fi
+endif
+	touch $(ARGUS_DIR)/.unpacked
+
+$(ARGUS_DIR)/.configured: $(ARGUS_DIR)/.unpacked
+	(cd $(ARGUS_DIR); rm -rf config.cache; \
+		$(TARGET_CONFIGURE_OPTS) CC_FOR_BUILD="$(HOSTCC)" \
+		CFLAGS="$(TARGET_CFLAGS)" \
+		$(ARGUS_TRAP_CHECK) \
+		./configure \
+		--target=$(GNU_TARGET_NAME) \
+		--host=$(GNU_TARGET_NAME) \
+		--build=$(GNU_HOST_NAME) \
+		--prefix=/usr \
+		$(ARGUS_CONFIG_OPTS) \
+	);
+	touch $(ARGUS_DIR)/.configured
+
+$(ARGUS_DIR)/$(ARGUS_BINARY): $(ARGUS_DIR)/.configured
+	$(TARGET_CONFIGURE_OPTS) $(MAKE) CC=$(TARGET_CC) -C $(ARGUS_DIR)
+
+$(TARGET_DIR)/$(ARGUS_TARGET_BINARY): $(ARGUS_DIR)/$(ARGUS_BINARY)
+	cp -dpf $(ARGUS_DIR)/$(ARGUS_BINARY) $@
+	$(STRIP) $@
+
+argus: uclibc libpcap $(TARGET_DIR)/$(ARGUS_TARGET_BINARY)
+
+argus-clean:
+	-$(MAKE) -C $(ARGUS_DIR) clean
+	rm -f $(TARGET_DIR)/$(ARGUS_TARGET_BINARY)
+
+argus-dirclean:
+	rm -rf $(ARGUS_DIR)
+#############################################################
+#
+# Toplevel Makefile options
+#
+#############################################################
+ifeq ($(strip $(BR2_PACKAGE_ARGUS)),y)
+TARGETS+=argus
+endif