开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 通讯编程 > 查看源码
net-pcap.cc
资源名称：ns-allinone-2.33.tar.gz　[点击查看]
上传用户：rrhhcc
上传日期：2015-12-11
资源大小：54129k
文件大小：24k
源码类别：

通讯编程

开发平台：

Visual C++

net-pcap.cc：源码内容
  1. /*-
  2.  * Copyright (c) 1998 The Regents of the University of California.
  3.  * All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that the following conditions
  7.  * are met:
  8.  * 1. Redistributions of source code must retain the above copyright
  9.  *    notice, this list of conditions and the following disclaimer.
  10.  * 2. Redistributions in binary form must reproduce the above copyright
  11.  *    notice, this list of conditions and the following disclaimer in the
  12.  *    documentation and/or other materials provided with the distribution.
  13.  * 3. All advertising materials mentioning features or use of this software
  14.  *    must display the following acknowledgement:
  15.  *      This product includes software developed by the University of
  16.  *      California, Berkeley and the Network Research Group at
  17.  *      Lawrence Berkeley Laboratory.
  18.  * 4. Neither the name of the University nor of the Laboratory may be used
  19.  *    to endorse or promote products derived from this software without
  20.  *    specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  34. #ifndef lint
  35. static const char rcsid[] =
  36.     "@(#) $Header: /cvsroot/nsnam/ns-2/emulate/net-pcap.cc,v 1.23 2005/09/07 06:35:45 tomh Exp $ (LBL)";
  37. #endif
  39. #include <stdio.h>
  40. #ifndef WIN32
  41. #include <unistd.h>
  42. #endif
  43. #include <time.h>
  44. #include <errno.h>
  45. #include <string.h>
  46. #ifdef WIN32
  47. #include <io.h>
  48. #define close closesocket
  49. #else
  50. #include <sys/param.h>
  51. #include <sys/socket.h>
  52. #include <sys/ioctl.h>
  53. #endif
  54. #if defined(sun) && defined(__svr4__)
  55. #include <sys/systeminfo.h>
  56. #endif
  58. #ifdef __cplusplus
  59. extern "C" {
  60. #include <pcap.h>
  61. }
  62. #else
  63. #include <pcap.h>
  64. #endif
  66. #include "config.h"
  67. #include "scheduler.h"
  68. #include "net.h"
  69. #include "tclcl.h"
  70. #include "packet.h"
  72. /*
  73.  * observations about pcap library
  74.  * device name is in the ifreq struct sense, should be doc'd
  75.  * pcap_lookupdev returns a ptr to static data
  76.  * q: does lookupdev only return devs in the AF_INET addr family?
  77.  * why does pcap_compile require a netmask? seems odd
  78.  * would like some way to tell it what buffer to use
  79.  * arriving packets have the link layer hdr at the beginning, doc
  80.  * not convenient/possible to open bpf read/write
  81.  * no real way to know what file (/dev/bpf?) it is using
  82.  * would be nice if pcap_lookdev helped out more by
  83.  * returning ifnet or ifreq or whatever structure
  84.  * pcap_lookupnet makes calls to get our addr, but
  85.  * then tosses it anyhow, should get us addr and netmask
  86.  * interface type codes could be via rfc1573
  87.  * see freebsd net/if_types.h
  88.  * want a way to set immed mode
  89.  * pcap_next masks errors by returning 0 if pcap_dispatch fails
  90.  * a pcap_t carries it's own internal buffer, and
  91.  * _dispatch gives pointers into it when invoked [eek]
  92.  * when you open pcap using a file, pcap_fileno always
  93.  * returns -1; not so convenient
  94.  *
  95.  */
  97. #define PNET_PSTATE_INACTIVE 0
  98. #define PNET_PSTATE_ACTIVE 1
  100. //
  101. // PcapNetwork: a "network" (source or possibly sink of packets)
  102. // this is a base class only-- the derived classes are:
  103. // PcapLiveNetwork [a live net; currently bpf + ethernet]
  104. // PcapFileNetwork [packets from a tcpdump-style trace file]
  105. //
  107. class PcapNetwork : public Network {
  109. public:
  110. PcapNetwork() : t_firstpkt_(0.0),
  111. pfd_(-1), pcnt_(0), local_netmask_(0) { }
  112. int rchannel() { return(pfd_); }
  113. int schannel() { return(pfd_); }
  114. virtual int command(int argc, const char*const* argv);
  116. virtual int open(int mode, const char *) = 0;
  117. virtual int skiphdr() = 0;
  118. virtual double gents(pcap_pkthdr*) = 0; // generate timestamp
  119. int recv(u_char *buf, int len, sockaddr&, double&); // get from net
  120. int send(u_char *buf, int len); // write to net
  121. int recv(netpkt_handler callback, void *clientdata); // get from net
  122. void close();
  123. void reset();
  125. int filter(const char*); // compile + install a filter
  126. int stat_pkts();
  127. int stat_pdrops();
  129. double offset_; // time offset to 1st pkt in a trace
  130. double t_firstpkt_; // ts of 1st pkt recvd
  132. protected:
  133. static void phandler(u_char* u, const pcap_pkthdr* h, const u_char* p);
  134. static void phandler_callback(u_char* u, const pcap_pkthdr* h, const u_char* p);
  135. virtual void bindvars() = 0;
  137. char errbuf_[PCAP_ERRBUF_SIZE]; // place to put err msgs
  138. char srcname_[PATH_MAX]; // device or file name
  139. int pfd_; // pcap fd
  140. int pcnt_; // # pkts counted
  141. int state_; // PNET_PSTATE_xxx (above)
  142. int optimize_; // bpf optimizer enable
  143. pcap_t* pcap_; // reference to pcap state
  144. struct bpf_program bpfpgm_; // generated program
  145. struct pcap_stat pcs_; // status
  147. unsigned int local_netmask_; // seems shouldn't be necessary :(
  148. };
  150. //
  151. // PcapLiveNetwork: a live network tap
  152. //
  154. struct NetworkAddress {
  155.         u_int   len_;
  156.         u_char  addr_[16]; // enough for IPv6 ip addr
  157. };
  159. class PcapLiveNetwork : public PcapNetwork {
  160. public:
  161. PcapLiveNetwork() : local_net_(0), dlink_type_(-1) {
  162. linkaddr_.len_ = 0;
  163. netaddr_.len_ = 0;
  164. bindvars(); reset();
  165. }
  166. NetworkAddress& laddr() { return (linkaddr_); }
  167. NetworkAddress& naddr() { return (netaddr_); }
  168. protected:
  169. double gents(pcap_pkthdr*) {
  170. return Scheduler::instance().clock();
  171. }
  173. int devtonaddr(const char* name, NetworkAddress&);
  175. int open(int mode);
  176. int open(int mode, const char*);
  177. int command(int argc, const char*const* argv);
  178. int skiphdr();
  179. const char* autodevname();
  180. void bindvars();
  182. int snaplen_; // # of bytes to grab
  183. int promisc_; // put intf into promisc mode?
  184. double timeout_;
  185. NetworkAddress linkaddr_; // link-layer address
  186. NetworkAddress netaddr_; // network-layer (IP) address
  188. unsigned int local_net_;
  189. int dlink_type_; // data link type (see pcap)
  190. private:
  191. // XXX somewhat specific to bpf-- this stuff is  a hack until pcap
  192. // can be fixed to allow for opening the bpf r/w
  193. #ifdef MT_OWN_PCAP
  194. pcap_t * pcap_open_live(char *, int slen, int prom, int, char *, int);
  195. int bpf_open(pcap_t *p, char *errbuf, int how);
  196. #endif
  197. };
  199. class PcapFileNetwork : public PcapNetwork {
  200. public:
  201. int open(int mode, const char *);
  202. int skiphdr() { return 0; } // XXX check me
  203. protected:
  204. double gents(pcap_pkthdr* p) {
  205. // time stamp of packet is its relative time
  206. // in the trace file, plus sim start time, plus offset
  207. double pts = p->ts.tv_sec + p->ts.tv_usec * 0.000001;
  208. pts -= t_firstpkt_;
  209. pts += offset_ + Scheduler::instance().clock();
  210. return (pts);
  211. }
  212. void bindvars();
  213. int command(int argc, const char*const* argv);
  214. };
  216. static class PcapLiveNetworkClass : public TclClass {
  217. public:
  218. PcapLiveNetworkClass() : TclClass("Network/Pcap/Live") {}
  219. TclObject* create(int, const char*const*) {
  220. return (new PcapLiveNetwork);
  221. }
  222. } net_pcaplive;
  224. static class PcapFileNetworkClass : public TclClass {
  225. public:
  226. PcapFileNetworkClass() : TclClass("Network/Pcap/File") {}
  227. TclObject* create(int, const char*const*) {
  228. return (new PcapFileNetwork);
  229. }
  230. } net_pcapfile;
  232. //
  233. // defs for base PcapNetwork class
  234. //
  236. void
  237. PcapNetwork::bindvars()
  238. {
  239. bind_bool("optimize_", &optimize_);
  240. }
  242. void
  243. PcapNetwork::reset()
  244. {
  245. state_ = PNET_PSTATE_INACTIVE;
  246. pfd_ = -1;
  247. pcap_ = NULL;
  248. *errbuf_ = '';
  249. *srcname_ = '';
  250. pcnt_ = 0;
  251. }
  253. void
  254. PcapNetwork::close()
  255. {
  256. if (state_ == PNET_PSTATE_ACTIVE && pcap_)
  257. pcap_close(pcap_);
  258. reset();
  259. }
  261. /* compile up a bpf program */
  262. /* XXXwe aren't using 'bcast', so don't care about mask... sigh */
  264. int
  265. PcapNetwork::filter(const char *pgm)
  266. {
  267. if (pcap_compile(pcap_, &bpfpgm_, (char *)pgm,
  268.     optimize_, local_netmask_) < 0) {
  269. fprintf(stderr, "pcapnet obj(%s): couldn't compile filter pgm",
  270. name());
  271. return -1;
  272. }
  273. if (pcap_setfilter(pcap_, &bpfpgm_) < 0) {
  274. fprintf(stderr, "pcapnet obj(%s): couldn't set filter pgm",
  275. name());
  276. return -1;
  277. }
  278. return(bpfpgm_.bf_len);
  279. }
  281. /* return number of pkts received */
  282. int
  283. PcapNetwork::stat_pkts()
  284. {
  285. if (pcap_stats(pcap_, &pcs_) < 0)
  286. return (-1);
  288. return (pcs_.ps_recv);
  289. }
  291. /* return number of pkts dropped */
  292. int
  293. PcapNetwork::stat_pdrops()
  294. {
  295. if (pcap_stats(pcap_, &pcs_) < 0)
  296. return (-1);
  298. return (pcs_.ps_drop);
  299. }
  301. #ifndef MIN
  302. #define MIN(x, y) ((x)<(y) ? (x) : (y))
  303. #endif
  305. #include "ether.h"
  306. /* recv is what others call to grab a packet from the pfilter */
  308. struct pcap_singleton {
  309.         struct pcap_pkthdr *hdr;
  310.         const u_char *pkt;
  311. };   
  313. struct pcap_singleton_callback {
  314.         netpkt_handler callback;
  315.         void *clientdata;
  316.         PcapNetwork *net;
  317. };   
  319. void
  320. PcapNetwork::phandler(u_char* userdata, const pcap_pkthdr* ph, const u_char* pkt)
  321. {
  322. pcap_singleton *ps = (pcap_singleton*) userdata;
  323. ps->hdr = (pcap_pkthdr*)ph;
  324. ps->pkt = (u_char*)pkt;
  325. }
  327. void
  328. PcapNetwork::phandler_callback(u_char* userdata, const pcap_pkthdr* ph, const u_char* pkt)
  329. {
  330. pcap_singleton_callback *ps = (pcap_singleton_callback*) userdata;
  332. Packet *p = Packet::alloc(ph->caplen);
  333. PcapNetwork *inst = ps->net;
  335. if (++(inst->pcnt_) == 1) {
  336. // mark time stamp of first pkt
  337. inst->t_firstpkt_ = ph->ts.tv_sec + ph->ts.tv_usec * 0.000001;
  338. }
  340. // link layer header will be placed at the beginning from pcap
  341. int s = inst->skiphdr(); // go to IP header
  342. memcpy(p->accessdata(), pkt + s, ph->caplen - s);
  344. ps->callback(ps->clientdata, p, ph->ts);
  345. }
  347. int
  348. PcapNetwork::recv(u_char *buf, int len, sockaddr& /*fromaddr*/, double &ts)
  349. {
  351. if (state_ != PNET_PSTATE_ACTIVE) {
  352. fprintf(stderr, "warning: net/pcap obj(%s) read-- not activen",
  353. name());
  354. return -1;
  355. }
  357. int pktcnt = 1; // all in buffer, or until error
  358. int np; // counts # of pkts dispatched
  359. pcap_singleton ps = { 0, 0 };
  360. np = pcap_dispatch(pcap_, pktcnt, phandler, (u_char*) &ps);
  361. if (np < 0) {
  362. fprintf(stderr,
  363. "PcapNetwork(%s): recv: pcap_dispatch: %sn",
  364.     name(), pcap_strerror(errno));
  365. return (np);
  366. } else if (np == 0) {
  367. /* we get here on EOF of a Pcap/File Network */
  368. return (np);
  369. } else if (np != pktcnt) {
  370. fprintf(stderr,
  371. "PcapNetwork(%s): warning: recv: pcap_dispatch: requested pktcnt (%d) doesn't match actual (%d)n",
  372.     name(), pktcnt, np);
  373. }
  375. pcap_pkthdr* ph = ps.hdr;
  377. if (ph == NULL || ps.pkt == NULL) {
  378. fprintf(stderr,
  379. "PcapNetwork(%s): recv: pcap_dispatch: no packet presentn",
  380.     name());
  381. return (-1);
  382. }
  384. if (++pcnt_ == 1) {
  385. // mark time stamp of first pkt
  386. t_firstpkt_ = ph->ts.tv_sec + ph->ts.tv_usec * 0.000001;
  387. }
  389. int n = MIN(ph->caplen, (unsigned)len);
  390. ts = gents(ph); // mark with timestamp
  391. // link layer header will be placed at the beginning from pcap
  392. int s = skiphdr(); // go to IP header
  393. memcpy(buf, ps.pkt + s, n - s);
  394. return n - s;
  395. }
  397. int
  398. PcapNetwork::recv(netpkt_handler callback, void *clientdata)
  399. {
  400. if (state_ != PNET_PSTATE_ACTIVE) {
  401. fprintf(stderr, "warning: net/pcap obj(%s) read-- not activen",
  402. name());
  403. return -1;
  404. }
  406. int pktcnt = -1; // all in buffer, or until error
  407. int np; // counts # of pkts dispatched
  408. pcap_singleton_callback ps = { callback, clientdata, this };
  410. np = pcap_dispatch(pcap_, pktcnt, phandler_callback, (u_char *)&ps);
  412. #ifdef MY_OWN_PCAP // directly access pcap_t's member
  413. assert( pcap_->cc == 0 ); // i.e. we have emptied pcap's buffer
  414. #endif // MY_OWN_PCAP
  415. return np;
  416. }
  418. /* send a packet out through the packet filter */
  419. int
  420. PcapNetwork::send(u_char *buf, int len)
  421. {
  422. int n;
  424. if ((n = write(pfd_, buf, len)) < 0)
  425. perror("write to pcap fd");
  427. return n;
  428. }
  430. int PcapNetwork::command(int argc, const char*const* argv)
  431. {
  432. Tcl& tcl = Tcl::instance();
  433. if (argc == 2) {
  434. if (strcmp(argv[1], "close") == 0) {
  435. close();
  436. return (TCL_OK);
  437. }
  438. if (strcmp(argv[1], "srcname") == 0) {
  439. tcl.result(srcname_);
  440. return (TCL_OK);
  441. }
  442. if (strcmp(argv[1], "pkts") == 0) {
  443. tcl.resultf("%d", stat_pkts());
  444. return (TCL_OK);
  445. }
  446. if (strcmp(argv[1], "pdrops") == 0) {
  447. tcl.resultf("%d", stat_pdrops());
  448. return (TCL_OK);
  449. }
  450. } else if (argc == 3) {
  451. if (strcmp(argv[1], "filter") == 0) {
  452. if (state_ != PNET_PSTATE_ACTIVE) {
  453. fprintf(stderr, "net/pcap obj(%s): can't install filter prior to opening data sourcen",
  454. name());
  455. return (TCL_ERROR);
  456. }
  457. int plen;
  458. if ((plen = filter(argv[2])) < 0) {
  459. fprintf(stderr, "problem compiling/installing filter programn");
  460. return (TCL_ERROR);
  461. }
  462. tcl.resultf("%d", plen);
  463. return (TCL_OK);
  464. }
  465. }
  466. return (Network::command(argc, argv));
  467. }
  469. //
  470. // defs for PcapLiveNetwork
  471. //
  473. #include <fcntl.h>
  475. #include <net/if.h>
  476. int
  477. PcapLiveNetwork::open(int mode, const char *devname)
  478. {
  479. close();
  480. #ifdef MY_OWN_PCAP
  481. pcap_ = pcap_open_live((char*) devname, snaplen_, promisc_,
  482.        int(timeout_ * 1000.), errbuf_, mode);
  483. #else
  484. pcap_ = pcap_open_live((char*) devname, snaplen_, promisc_,
  485.        int(timeout_ * 1000.), errbuf_);
  486. #endif // MY_OWN_PCAP
  487. if (pcap_ == NULL) {
  488. fprintf(stderr,
  489.   "pcap/live object (%s) couldn't open packet source %s: %sn",
  490. name(), devname, errbuf_);
  491. return -1;
  492. }
  493. mode_ = mode;
  494. dlink_type_ = pcap_datalink(pcap_);
  495. pfd_ = pcap_fileno(pcap_);
  496. strncpy(srcname_, devname, sizeof(srcname_)-1);
  497. {
  498. // use SIOCGIFADDR hook in bpf to get link addr
  499. struct ifreq ifr;
  500. struct sockaddr *sa = &ifr.ifr_addr;
  501. #ifdef HAVE_SIOCGIFHWADDR
  502. memset(&ifr, 0, sizeof(struct ifreq));
  503. strcpy(ifr.ifr_name, devname);
  504. if (ioctl(pfd_, SIOCGIFHWADDR, &ifr) < 0) {
  505. fprintf(stderr,
  506.   "pcap/live (%s) SIOCGIFHWADDR on bpf fd %dn",
  507.   name(), pfd_);
  508. }
  509. #else
  510. if (ioctl(pfd_, SIOCGIFADDR, &ifr) < 0) {
  511. fprintf(stderr,
  512.   "pcap/live (%s) SIOCGIFADDR on bpf fd %dn",
  513.   name(), pfd_);
  514. }
  515. #endif
  516. if (dlink_type_ != DLT_EN10MB) {
  517. fprintf(stderr,
  518. "sorry, only ethernet supportedn");
  519. return -1;
  520. }
  521. linkaddr_.len_ = ETHER_ADDR_LEN; // for now
  522. memcpy(linkaddr_.addr_, sa->sa_data, linkaddr_.len_);
  523. }
  525. (void) devtonaddr(devname, netaddr_);
  527. state_ = PNET_PSTATE_ACTIVE;
  529. if (pcap_lookupnet(srcname_, &local_net_, &local_netmask_, errbuf_) < 0) {
  530. fprintf(stderr,
  531.   "warning: pcap/live (%s) couldn't get local IP network info: %sn",
  532.   name(), errbuf_) ;
  533. }
  534. #if !defined(__linux__)&&!defined(__APPLE__)
  535. {
  536. int immed = 1;
  537. if (ioctl(pfd_, BIOCIMMEDIATE, &immed) < 0) {
  538. fprintf(stderr,
  539. "warning: pcap/live (%s) couldn't set immedn",
  540. name());
  541. perror("ioctl(BIOCIMMEDIATE)");
  542. }
  543. }
  544. #endif
  545. return 0;
  546. }
  548. /*
  549.  * how many bytes of link-hdr to skip before net-layer hdr
  550.  */
  552. int
  553. PcapLiveNetwork::skiphdr()
  554. {
  555. switch (dlink_type_) {
  556. case DLT_NULL:
  557. return 0;
  559. case DLT_EN10MB:
  560. return ETHER_HDR_LEN;
  562. default:
  563. fprintf(stderr,
  564.     "Network/Pcap/Live(%s): unknown link type: %dn",
  565. name(), dlink_type_);
  566. }
  567. return -1;
  568. }
  570. const char *
  571. PcapLiveNetwork::autodevname()
  572. {
  573. const char *dname;
  574. if ((dname = pcap_lookupdev(errbuf_)) == NULL) {
  575. fprintf(stderr, "warning: PcapNet/Live(%s) : %sn",
  576. name(), errbuf_);
  577. return (NULL);
  578. }
  579. return (dname); // ptr to static data in pcap library
  580. }
  582. /*
  583.  * devtonaddr -- map device name to its IP/Network layer address
  584.  * this routine wouldn't be necessary if pcap_lookupnet gave
  585.  * out the info it gets anyhow
  586.  */
  588. #include <netinet/in.h>
  590. int
  591. PcapLiveNetwork::devtonaddr(const char *devname, NetworkAddress& na)
  592. {
  593.         register int fd;
  594.         ifreq ifr;
  595.                                 
  596.         fd = socket(AF_INET, SOCK_DGRAM, 0);
  597.         if (fd < 0) {       
  598.                 fprintf(stderr,
  599. "PcapLiveNet(%s): devtoaddr: couldn't create sockn",
  600. name());
  601.                 return (-1);
  602.         }
  603.         memset(&ifr, 0, sizeof(ifr));
  604. #ifdef linux
  605.         /* XXX Work around Linux kernel bug */
  606.         ifr.ifr_addr.sa_family = AF_INET;
  607. #endif   
  608.         (void)strncpy(ifr.ifr_name, devname, sizeof(ifr.ifr_name));
  609.         if (ioctl(fd, SIOCGIFADDR, (char *)&ifr) < 0) {
  610.                 fprintf(stderr, "PcapLiveNetwork(%s): devtoaddr: no addrn",
  611. name());
  612.                 (void)::close(fd);   
  613.                 return (-1);
  614.         }               
  615. sockaddr* sa = &ifr.ifr_addr;
  616. if (sa->sa_family != AF_INET) {
  617.                 fprintf(stderr,
  618. "PcapLiveNet(%s): af not AF_INET (%d)n",
  619. name(), sa->sa_family);
  620. }
  621. sockaddr_in* sin = (sockaddr_in*) sa;
  622. na.len_ = 4; // for now, assump IPv4
  623. memset(na.addr_, 0, sizeof(na.addr_));
  624. unsigned sz = sizeof(na.addr_);
  625. if (sizeof(ifr) < sz)
  626. sz = sizeof(ifr);
  627. memcpy(na.addr_, &sin->sin_addr, sz);
  628. return (0);
  629. }
  632. void
  633. PcapLiveNetwork::bindvars()
  634. {
  635. bind("snaplen_", &snaplen_);
  636. bind_bool("promisc_", &promisc_);
  637. bind_time("timeout_", &timeout_);
  638. bind("offset_", &offset_);
  639. PcapNetwork::bindvars();
  640. }
  642. void
  643. PcapFileNetwork::bindvars()
  644. {
  645. bind("offset_", &offset_);
  646. }
  648. int
  649. PcapLiveNetwork::open(int mode)
  650. {
  651. return (open(mode, autodevname()));
  652. }
  654. int PcapLiveNetwork::command(int argc, const char*const* argv)
  655. {
  657. Tcl& tcl = Tcl::instance();
  658. if (argc == 2) {
  659. if (strcmp(argv[1], "linkaddr") == 0) {
  660. /// XXX: only for ethernet now
  661. tcl.result(Ethernet::etheraddr_string(linkaddr_.addr_));
  662. return (TCL_OK);
  663. }
  664. if (strcmp(argv[1], "netaddr") == 0) {
  665. if (netaddr_.len_ != 4) {
  666. fprintf(stderr,
  667.   "PcapLive(%s): net addr not len 4 (%d)n",
  668. name(), netaddr_.len_);
  669. return (TCL_ERROR);
  670. }
  671. tcl.resultf("%d.%d.%d.%d",
  672. netaddr_.addr_[0],
  673. netaddr_.addr_[1],
  674. netaddr_.addr_[2],
  675. netaddr_.addr_[3]);
  676. return (TCL_OK);
  677. }
  678. } else if (argc == 3) {
  679. // $obj open mode
  680. if (strcmp(argv[1], "open") == 0) {
  681. int mode = parsemode(argv[2]);
  682. if (open(mode) < 0)
  683. return (TCL_ERROR);
  684. tcl.result(srcname_);
  685. return (TCL_OK);
  686. }
  687. } else if (argc == 4) {
  688. // $obj open mode devicename
  689. if (strcmp(argv[1], "open") == 0) {
  690. int mode = parsemode(argv[2]);
  691. if (open(mode, argv[3]) < 0)
  692. return (TCL_ERROR);
  693. tcl.result(srcname_);
  694. return (TCL_OK);
  695. }
  696. }
  697. return (PcapNetwork::command(argc, argv));
  698. }
  700. //
  701. // defs for PcapFileNetwork
  702. // use a file instead of a live network
  703. //
  705. int
  706. PcapFileNetwork::open(int /*mode*/, const char *filename)
  707. {
  709. close();
  710. pcap_ = pcap_open_offline((char*) filename, errbuf_);
  711. if (pcap_ == NULL) {
  712. fprintf(stderr,
  713.   "pcap/file object (%s) couldn't open packet source %s: %sn",
  714. name(), filename, errbuf_);
  715. return -1;
  716. }
  717. mode_ = O_RDONLY; // sorry, that's all for now
  718. //
  719. // pcap only ever puts -1 in the pcap_fileno, which
  720. // isn't so convenient, so do this instead:
  721. // pfd_ = pcap_fileno(pcap_);
  722. pfd_ = fileno(pcap_file(pcap_));
  723. strncpy(srcname_, filename, sizeof(srcname_)-1);
  724. state_ = PNET_PSTATE_ACTIVE;
  725. return 0;
  726. }
  728. int PcapFileNetwork::command(int argc, const char*const* argv)
  729. {
  731. Tcl& tcl = Tcl::instance();
  732. if (argc == 4) {
  733. // $obj open mode filename
  734. if (strcmp(argv[1], "open") == 0) {
  735. int mode = parsemode(argv[2]);
  736. if (open(mode, argv[3]) < 0)
  737. return (TCL_ERROR);
  738. tcl.resultf("%s", argv[3]);
  739. return (TCL_OK);
  740. }
  741. }
  742. return (PcapNetwork::command(argc, argv));
  743. }
  745. //
  746. // XXX: the following routines are unfortunately necessary, 
  747. // because libpcap has no obvious was of making the bpf fd
  748. // be read-write :(.  The implication here is nasty:
  749. // our own version of bpf_open and pcap_open_live
  750. // and the later routine requires the struct pcap internal state
  752. /*   
  753.  * Savefile
  754.  */  
  755. struct pcap_sf {
  756.         FILE *rfile; 
  757.         int swapped;
  758.         int version_major;
  759.         int version_minor;
  760.         u_char *base;
  761. };   
  762.      
  763. struct pcap_md {
  764.         struct pcap_stat stat;
  765.         /*XXX*/ 
  766.         int use_bpf;
  767.         u_long  TotPkts;        /* can't oflow for 79 hrs on ether */
  768.         u_long  TotAccepted;    /* count accepted by filter */
  769.         u_long  TotDrops;       /* count of dropped packets */
  770.         long    TotMissed;      /* missed by i/f during this run */
  771.         long    OrigMissed;     /* missed by i/f before this run */
  772. #ifdef linux
  773.         int pad;
  774.         int skip;
  775.         char *device;
  776. #endif
  777. };   
  780. struct pcap {
  781.         int fd;
  782.         int snapshot;
  783.         int linktype;
  784.         int tzoff;              /* timezone offset */
  785.         int offset;             /* offset for proper alignment */
  787.         struct pcap_sf sf;
  788.         struct pcap_md md;
  790.         /*
  791.          * Read buffer.
  792.          */
  793.         int bufsize;
  794.         u_char *buffer;
  795.         u_char *bp;
  796.         int cc;
  798.         /*
  799.          * Place holder for pcap_next().
  800.          */
  801.         u_char *pkt;
  803.         
  804.         /*
  805.          * Placeholder for filter code if bpf not in kernel.
  806.          */
  807.         struct bpf_program fcode;
  809.         char errbuf[PCAP_ERRBUF_SIZE];
  810. };
  813. /*
  814.  * the routines bpf_open and pcap_open_live really
  815.  * should not be here, and instead should be part of the
  816.  * pcap library.  Unfortunately, if we ever want to writes to
  817.  * the bpf fd, we need to open it r/w, and the normal pcap
  818.  * library does not permit us to do this.  So for now, here
  819.  * are these routines.
  820.  */
  822. #include <net/if.h>
  824. #ifdef MY_OWN_PCAP
  825. int
  826. PcapLiveNetwork::bpf_open(pcap_t *, char *errbuf, int how)
  827. {
  828.         int fd;
  829.         int n = 0;
  830.         char device[sizeof "/dev/bpf000"];
  832.         /*
  833.          * Go through all the minors and find one that isn't in use.
  834.          */
  835.         do {
  836.                 (void)sprintf(device, "/dev/bpf%d", n++);
  837.                 fd = ::open(device, how, 0);
  838.         } while (fd < 0 && n < 1000 && errno == EBUSY);
  840.         /*
  841.          * XXX better message for all minors used
  842.          */
  843.         if (fd < 0)
  844.                 sprintf(errbuf, "%s: %s", device, pcap_strerror(errno));
  846.         return (fd);
  847. }
  849. pcap_t *
  850. PcapLiveNetwork::pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf, int how)
  851. {
  852.         int fd;
  853.         struct ifreq ifr;
  854.         struct bpf_version bv;
  855.         u_int v;
  856.         pcap_t *p;
  858.         p = (pcap_t *)malloc(sizeof(*p));
  859.         if (p == NULL) {
  860.                 sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  861.                 return (NULL);
  862.         }
  863.         bzero(p, sizeof(*p));
  864.         fd = bpf_open(p, ebuf, how);
  865.         if (fd < 0)
  866.                 goto bad;
  868.         p->fd = fd;
  869.         p->snapshot = snaplen;
  871.         if (ioctl(fd, BIOCVERSION, (caddr_t)&bv) < 0) {
  872.                 sprintf(ebuf, "BIOCVERSION: %s", pcap_strerror(errno));
  873.                 goto bad;
  874.         }
  875.         if (bv.bv_major != BPF_MAJOR_VERSION ||
  876.             bv.bv_minor < BPF_MINOR_VERSION) {
  877.                 sprintf(ebuf, "kernel bpf filter out of date");
  878.                 goto bad;
  879.         }
  880.         (void)strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
  881.         if (ioctl(fd, BIOCSETIF, (caddr_t)&ifr) < 0) {
  882.                 sprintf(ebuf, "%s: %s", device, pcap_strerror(errno));
  883.                 goto bad;
  884.         }
  885.         /* Get the data link layer type. */
  886.         if (ioctl(fd, BIOCGDLT, (caddr_t)&v) < 0) {
  887.                 sprintf(ebuf, "BIOCGDLT: %s", pcap_strerror(errno));
  888.                 goto bad;
  889.         }
  890. #if _BSDI_VERSION - 0 >= 199510
  891.         /* The SLIP and PPP link layer header changed in BSD/OS 2.1 */
  892.         switch (v) {
  894.         case DLT_SLIP:
  895.                 v = DLT_SLIP_BSDOS;
  896.                 break;
  897.         case DLT_PPP:
  898.                 v = DLT_PPP_BSDOS;
  899.                 break;
  900.         }
  901. #endif  
  902.         p->linktype = v;
  904.         /* set timeout */
  905.         if (to_ms != 0) {
  906.                 struct timeval to;
  907.                 to.tv_sec = to_ms / 1000;
  908.                 to.tv_usec = (to_ms * 1000) % 1000000;
  909.                 if (ioctl(p->fd, BIOCSRTIMEOUT, (caddr_t)&to) < 0) {
  910.                         sprintf(ebuf, "BIOCSRTIMEOUT: %s",
  911.                                 pcap_strerror(errno));
  912.                         goto bad;
  913.                 }
  914.         }
  915.         if (promisc)
  916.                 /* set promiscuous mode, okay if it fails */
  917.                 (void)ioctl(p->fd, BIOCPROMISC, NULL); 
  919.         if (ioctl(fd, BIOCGBLEN, (caddr_t)&v) < 0) {
  920.                 sprintf(ebuf, "BIOCGBLEN: %s", pcap_strerror(errno));
  921.                 goto bad;
  922.         }   
  923.         p->bufsize = v;
  924.         p->buffer = (u_char *)malloc(p->bufsize);
  925.         if (p->buffer == NULL) {
  926.                 sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  927.                 goto bad;
  928.         }       
  930.         return (p);
  931.  bad:   
  932.         ::close(fd);
  933.         free(p);
  934.         return (NULL);
  935. }
  936. #endif // MY_OWN_PCAP