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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Telnet服务器 > 查看源码
pcap-linux.c
资源名称：nessus-libraries_2.2.10.orig.tar.gz　[点击查看]
上传用户：tjescc
上传日期：2021-02-23
资源大小：419k
文件大小：8k
源码类别：

Telnet服务器

开发平台：

Unix_Linux

pcap-linux.c：源码内容
  1. /*
  2.  * Copyright (c) 1996, 1997
  3.  * The Regents of the University of California.  All rights reserved.
  4.  *
  5.  * Redistribution and use in source and binary forms, with or without
  6.  * modification, are permitted provided that: (1) source code distributions
  7.  * retain the above copyright notice and this paragraph in its entirety, (2)
  8.  * distributions including binary code include the above copyright notice and
  9.  * this paragraph in its entirety in the documentation or other materials
  10.  * provided with the distribution, and (3) all advertising materials mentioning
  11.  * features or use of this software display the following acknowledgement:
  12.  * ``This product includes software developed by the University of California,
  13.  * Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
  14.  * the University nor the names of its contributors may be used to endorse
  15.  * or promote products derived from this software without specific prior
  16.  * written permission.
  17.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  18.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  19.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  20.  */
  21. #ifndef lint
  22. static const char rcsid[] =
  23.     "@(#) $Header: /usr/local/cvs/nessus-libraries/libpcap-nessus/pcap-linux.c,v 1.5 2003/03/07 00:57:40 renaud Exp $ (LBL)";
  24. #endif
  26. #include <sys/param.h>
  27. #include <sys/ioctl.h>
  28. #include <sys/socket.h>
  29. #include <sys/time.h>
  31. #include <net/if.h>
  32. #ifdef HAVE_NET_IF_ARP_H
  33. #include <net/if_arp.h>
  34. #else
  35. #include <linux/if_arp.h>
  36. #endif
  37. #include <linux/if_ether.h>
  39. #include <netinet/in.h>
  41. #include <errno.h>
  42. #include <malloc.h>
  43. #include <stdio.h>
  44. #include <stdlib.h>
  45. #include <string.h>
  46. #include <unistd.h>
  48. static struct ifreq saved_ifr;
  50. #include "pcap-int.h"
  52. #include "gnuc.h"
  53. #ifdef HAVE_OS_PROTO_H
  54. #include "os-proto.h"
  55. #endif
  57. #define TIMEVAL_SUBTRACT(a,b)  ((a.tv_sec - b.tv_sec) * 1000000 + a.tv_usec - b.tv_usec)
  59. static int timeout;
  61. void linux_restore_ifr(void);
  64. int
  65. pcap_stats(pcap_t *p, struct pcap_stat *ps)
  66. {
  68. *ps = p->md.stat;
  69. return (0);
  70. }
  72. int
  73. pcap_read(pcap_t *p, int cnt, pcap_handler callback, u_char *user)
  74. {
  75. register int cc;
  76. register int bufsize;
  77. register int caplen;
  78. register u_char *bp;
  79. struct sockaddr from;
  80. int fromlen;
  81. fd_set fd_r;
  82. struct timeval select_time, start, now, tmp;
  83. int res;
  84. fromlen = sizeof(from);
  86. select_time.tv_sec = timeout / 1000;
  87. select_time.tv_usec = (timeout % 1000) * 1000;
  88. gettimeofday(&start, NULL);
  91. do {
  93.   FD_ZERO(&fd_r);
  94.   FD_SET(p->fd, &fd_r );
  96.   bp = p->buffer + p->offset;
  97.   bufsize = p->bufsize - p->offset;
  98.   if (p->md.pad > 0) {
  99.     memset(bp, 0, p->md.pad);
  100.     bp += p->md.pad;
  101.     bufsize -= p->md.pad;
  102.   }
  104.   tmp = select_time; /* Because linux mucks with the timeout in select() */
  105.   res = select(p->fd+1, &fd_r, NULL, NULL, &tmp);
  106.   if (res < 0) {
  107.     sprintf(p->errbuf, "select: %s", pcap_strerror(errno));
  108.     return (-1);
  109.   } else if (res > 0) {
  110.     fromlen = sizeof(from);
  111.     while ((cc = recvfrom(p->fd, bp, bufsize, 0, &from, &fromlen)) < 0) {
  112.       /* Don't choke when we get ptraced */
  113.       if (errno != EINTR && errno != EAGAIN) {
  114. sprintf(p->errbuf, "read: %s", pcap_strerror(errno));
  115. return (-1);
  116.       }
  117.     }
  118.     
  119.     if (!strcmp(p->md.device, from.sa_data)) {
  120.       /* If we need have leading zero bytes, adjust count */
  121.       cc += p->md.pad;
  122.       bp = p->buffer + p->offset;
  123.       
  124.       /* If we need to step over leading junk, adjust count and pointer */
  125.       cc -= p->md.skip;
  126.       bp += p->md.skip;
  127.       
  128.       /* Captured length can't exceed our read buffer size */
  129. caplen = cc;
  130. if (caplen > bufsize)
  131.   caplen = bufsize;
  133. /* Captured length can't exceed the snapshot length */
  134. if (caplen > p->snapshot)
  135.   caplen = p->snapshot;
  137. if (p->fcode.bf_insns == NULL ||
  138.     bpf_filter(p->fcode.bf_insns, bp, cc, caplen)) {
  139.   struct pcap_pkthdr h;
  140.   
  141.   ++p->md.stat.ps_recv;
  142.   /* Get timestamp */
  143.   if (ioctl(p->fd, SIOCGSTAMP, &h.ts) < 0) {
  144.     sprintf(p->errbuf, "SIOCGSTAMP: %s",
  145.                             pcap_strerror(errno));
  146.     return (-1);
  147.   }
  148.   h.len = cc;
  149.   h.caplen = caplen;
  150.   (*callback)(user, &h, bp);
  151.   return (1);
  152. }
  153.       }
  154.     }
  155.   gettimeofday(&now, NULL);
  156. } while((timeout == 0 && res) || (TIMEVAL_SUBTRACT(now,start) < timeout * 1000));
  158. return 0;
  159. }
  161. pcap_t *
  162. pcap_open_live(char *device, int snaplen, int promisc, int to_ms, char *ebuf)
  163. {
  164. register int fd, broadcast;
  165. register pcap_t *p;
  166. struct ifreq ifr;
  167. struct sockaddr sa;
  169. timeout = to_ms;
  171. p = (pcap_t *)malloc(sizeof(*p));
  172. if (p == NULL) {
  173. sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  174. return (NULL);
  175. }
  176. memset(p, 0, sizeof(*p));
  177. fd = -1;
  179. fd = socket(PF_INET, SOCK_PACKET, htons(ETH_P_ALL));
  180. if (fd < 0) {
  181. sprintf(ebuf, "socket: %s", pcap_strerror(errno));
  182. goto bad;
  183. }
  184. p->fd = fd;
  186. /* Bind to the interface name */
  187. memset(&sa, 0, sizeof(sa));
  188. sa.sa_family = AF_INET;
  189. (void)strncpy(sa.sa_data, device, sizeof(sa.sa_data));
  190. if (bind(p->fd, &sa, sizeof(sa))) {
  191. sprintf(ebuf, "bind: %s: %s", device, pcap_strerror(errno));
  192. goto bad;
  193. }
  195. memset(&ifr, 0, sizeof(ifr));
  196. strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
  197. if (ioctl(p->fd, SIOCGIFHWADDR, &ifr) < 0 ) {
  198. sprintf(ebuf, "SIOCGIFHWADDR: %s", pcap_strerror(errno));
  199. goto bad;
  200. }
  201. broadcast = 0;
  202. switch (ifr.ifr_hwaddr.sa_family) {
  204. case ARPHRD_ETHER:
  205. case ARPHRD_METRICOM:
  206. p->linktype = DLT_EN10MB;
  207. p->offset = 2;
  208. ++broadcast;
  209. break;
  211. case ARPHRD_EETHER:
  212. p->linktype = DLT_EN3MB;
  213. ++broadcast;
  214. break;
  216. case ARPHRD_AX25:
  217. p->linktype = DLT_AX25;
  218. ++broadcast;
  219. break;
  221. #if defined(ARPHRD_IEEE802_TR) && defined(DLT_IEEE802)
  222. case ARPHRD_IEEE802_TR:
  223.                p->linktype = DLT_IEEE802;
  224.                ++broadcast;
  225.                break;
  226. #endif
  228. case ARPHRD_PRONET:
  229. p->linktype = DLT_PRONET;
  230. break;
  232. case ARPHRD_CHAOS:
  233. p->linktype = DLT_CHAOS;
  234. break;
  236. case ARPHRD_IEEE802:
  237. p->linktype = DLT_IEEE802;
  238. ++broadcast;
  239. break;
  241. case ARPHRD_ARCNET:
  242. p->linktype = DLT_ARCNET;
  243. ++broadcast;
  244. break;
  246. case ARPHRD_SLIP:
  247. case ARPHRD_CSLIP:
  248. case ARPHRD_SLIP6:
  249. case ARPHRD_CSLIP6:
  250. case ARPHRD_PPP:
  251. p->linktype = DLT_RAW;
  252. break;
  254. case ARPHRD_LOOPBACK:
  255. p->linktype = DLT_NULL;
  256. p->md.pad = 2;
  257. p->md.skip = 12;
  258. break;
  260. #ifdef ARPHRD_FDDI
  261. /* Not all versions of the kernel has this define */
  262. case ARPHRD_FDDI:
  263. p->linktype = DLT_FDDI;
  264. ++broadcast;
  265. break;
  266. #endif
  268. #ifdef notdef
  269. case ARPHRD_LOCALTLK:
  270. case ARPHRD_NETROM:
  271. case ARPHRD_APPLETLK:
  272. case ARPHRD_DLCI:
  273. case ARPHRD_RSRVD:
  274. case ARPHRD_ADAPT:
  275. case ARPHRD_TUNNEL:
  276. case ARPHRD_TUNNEL6:
  277. case ARPHRD_FRAD:
  278. case ARPHRD_SKIP:
  279. /* XXX currently do not know what to do with these... */
  280. abort();
  281. #endif
  283. default:
  284. sprintf(ebuf, "unknown physical layer type 0x%x",
  285.     ifr.ifr_hwaddr.sa_family);
  286. goto bad;
  287. }
  289. /* Base the buffer size on the interface MTU */
  290. memset(&ifr, 0, sizeof(ifr));
  291. strncpy(ifr.ifr_name, device, sizeof(ifr.ifr_name));
  292. if (ioctl(p->fd, SIOCGIFMTU, &ifr) < 0 ) {
  293. sprintf(ebuf, "SIOCGIFMTU: %s", pcap_strerror(errno));
  294. goto bad;
  295. }
  297. /* Leave room for link header (which is never large under linux...) */
  298. p->bufsize = ifr.ifr_mtu + 64;
  300. p->buffer = (u_char *)malloc(p->bufsize + p->offset);
  301. if (p->buffer == NULL) {
  302. sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  303. goto bad;
  304. }
  306. /* XXX */
  307. if (promisc && broadcast) {
  308. memset(&ifr, 0, sizeof(ifr));
  309. strcpy(ifr.ifr_name, device);
  310. if (ioctl(p->fd, SIOCGIFFLAGS, &ifr) < 0 ) {
  311. sprintf(ebuf, "SIOCGIFFLAGS: %s", pcap_strerror(errno));
  312. goto bad;
  313. }
  314. saved_ifr = ifr;
  315. ifr.ifr_flags |= IFF_PROMISC;
  316. if (ioctl(p->fd, SIOCSIFFLAGS, &ifr) < 0 ) {
  317. sprintf(ebuf, "SIOCSIFFLAGS: %s", pcap_strerror(errno));
  318. goto bad;
  319. }
  320. ifr.ifr_flags &= ~IFF_PROMISC;
  321. atexit(linux_restore_ifr);
  322. }
  324. p->md.device = strdup(device);
  325. if (p->md.device == NULL) {
  326. sprintf(ebuf, "malloc: %s", pcap_strerror(errno));
  327. goto bad;
  328. }
  329. p->snapshot = snaplen;
  331. return (p);
  332. bad:
  333. if (fd >= 0)
  334. (void)close(fd);
  335. if (p->buffer != NULL)
  336. free(p->buffer);
  337. if (p->md.device != NULL)
  338. free(p->md.device);
  339. free(p);
  340. return (NULL);
  341. }
  343. int
  344. pcap_setfilter(pcap_t *p, struct bpf_program *fp)
  345. {
  347. p->fcode = *fp;
  348. return (0);
  349. }
  351. void
  352. linux_restore_ifr(void)
  353. {
  354. register int fd;
  356. fd = socket(PF_INET, SOCK_PACKET, htons(0x0003));
  357. if (fd < 0)
  358. fprintf(stderr, "linux socket: %s", pcap_strerror(errno));
  359. else if (ioctl(fd, SIOCSIFFLAGS, &saved_ifr) < 0)
  360. fprintf(stderr, "linux SIOCSIFFLAGS: %s", pcap_strerror(errno));
  361. }