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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
bpf_filter.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：12k
源码类别：

VxWorks

开发平台：

C/C++

bpf_filter.c：源码内容
  1. /* bpf_filter.c - Berkeley Packet Filter support routines for filter program */
  3. /* Copyright 1999 - 2002 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*-
  7.  * Copyright (c) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997
  8.  * The Regents of the University of California.  All rights reserved.
  9.  *
  10.  * This code is derived from the Stanford/CMU enet packet filter,
  11.  * (net/enet.c) distributed as part of 4.3BSD, and code contributed
  12.  * to Berkeley by Steven McCanne and Van Jacobson both of Lawrence 
  13.  * Berkeley Laboratory.
  14.  *
  15.  * Redistribution and use in source and binary forms, with or without
  16.  * modification, are permitted provided that the following conditions
  17.  * are met:
  18.  * 1. Redistributions of source code must retain the above copyright
  19.  *    notice, this list of conditions and the following disclaimer.
  20.  * 2. Redistributions in binary form must reproduce the above copyright
  21.  *    notice, this list of conditions and the following disclaimer in the
  22.  *    documentation and/or other materials provided with the distribution.
  23.  * 3. All advertising materials mentioning features or use of this software
  24.  *    must display the following acknowledgement:
  25.  * This product includes software developed by the University of
  26.  * California, Berkeley and its contributors.
  27.  * 4. Neither the name of the University nor the names of its contributors
  28.  *    may be used to endorse or promote products derived from this software
  29.  *    without specific prior written permission.
  30.  *
  31.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  32.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  33.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  34.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  35.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  39.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  40.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  41.  * SUCH DAMAGE.
  42.  *
  43.  * @(#)bpf.c 7.5 (Berkeley) 7/15/91
  44.  */
  46. static const char rcsid[] =
  47.     "@(#) $Header: bpf_filter.c,v 1.33 97/04/26 13:37:18 leres Exp $ (LBL)";
  49. /*
  50. modification history
  51. --------------------
  52. 01c,25apr02,wap  Don't choose EXTRACT_xx() macros based on byte-ordering (SPR
  53.                  #76316)
  54. 01b,26oct00,spm  fixed merge from tor3_x branch and updated mod history
  55. 01a,23oct00,niq  created from version 01a of tor3_x branch
  56. */
  58. #include <sys/types.h>
  59. #include <sys/times.h>
  60. #include <net/bpf.h>
  62. #define int32 bpf_int32
  63. #define u_int32 bpf_u_int32
  65. /*
  66.  * On architectures where unaligned accesses are legal, we can use
  67.  * a slightly simpler set of macros.
  68.  */
  69. #if (CPU_FAMILY == I80X86)
  70. #include <netinet/in.h>
  72. #define EXTRACT_SHORT(p) ((u_short)ntohs(*(u_short *)p))
  73. #define EXTRACT_LONG(p) (ntohl(*(u_int32 *)p))
  75. #else
  77. #define EXTRACT_SHORT(p)
  78. ((u_short)
  79. ((u_short)*((u_char *)p+0)<<8|
  80.  (u_short)*((u_char *)p+1)<<0))
  81. #define EXTRACT_LONG(p)
  82. ((u_int32)*((u_char *)p+0)<<24|
  83.  (u_int32)*((u_char *)p+1)<<16|
  84.  (u_int32)*((u_char *)p+2)<<8|
  85.  (u_int32)*((u_char *)p+3)<<0)
  87. #endif
  89. #include <net/mbuf.h>
  90. #define MINDEX(len, m, k) 
  91. { 
  92. len = m->m_len; 
  93. while (k >= len) { 
  94. k -= len; 
  95. m = m->m_next; 
  96. if (m == 0) 
  97. return 0; 
  98. len = m->m_len; 
  99. } 
  100. }
  102. static int
  103. m_xword(m, k, err)
  104. register struct mbuf *m;
  105. register int k, *err;
  106. {
  107. register int len;
  108. register u_char *cp, *np;
  109. register struct mbuf *m0;
  111. MINDEX(len, m, k);
  112. cp = mtod(m, u_char *) + k;
  113. if (len - k >= 4) {
  114. *err = 0;
  115. return EXTRACT_LONG(cp);
  116. }
  117. m0 = m->m_next;
  118. if (m0 == 0 || m0->m_len + len - k < 4)
  119. goto bad;
  120. *err = 0;
  121. np = mtod(m0, u_char *);
  122. switch (len - k) {
  124. case 1:
  125. return (cp[0] << 24) | (np[0] << 16) | (np[1] << 8) | np[2];
  127. case 2:
  128. return (cp[0] << 24) | (cp[1] << 16) | (np[0] << 8) | np[1];
  130. default:
  131. return (cp[0] << 24) | (cp[1] << 16) | (cp[2] << 8) | np[0];
  132. }
  133.     bad:
  134. *err = 1;
  135. return 0;
  136. }
  138. static int
  139. m_xhalf(m, k, err)
  140. register struct mbuf *m;
  141. register int k, *err;
  142. {
  143. register int len;
  144. register u_char *cp;
  145. register struct mbuf *m0;
  147. MINDEX(len, m, k);
  148. cp = mtod(m, u_char *) + k;
  149. if (len - k >= 2) {
  150. *err = 0;
  151. return EXTRACT_SHORT(cp);
  152. }
  153. m0 = m->m_next;
  154. if (m0 == 0)
  155. goto bad;
  156. *err = 0;
  157. return (cp[0] << 8) | mtod(m0, u_char *)[0];
  158.  bad:
  159. *err = 1;
  160. return 0;
  161. }
  163. /*
  164.  * Execute the filter program starting at pc on the packet p
  165.  * wirelen is the length of the original packet
  166.  * buflen is the amount of data present in the first mBlk (0 if unknown)
  167.  * type is the MUX encoding for the frame type and offset is the
  168.  *      value needed to skip the link-level header
  169.  */
  170. u_int
  171. bpf_filter(pc, p, wirelen, buflen, type, offset)
  172. register struct bpf_insn *pc;
  173. register u_char *p;
  174. u_int wirelen;
  175. register u_int buflen;
  176.         long type;
  177.         int offset;
  178. {
  179. register u_int32 A, X;
  180. register int k;
  181. int32 mem[BPF_MEMWORDS];
  183. if (pc == 0)
  184. /*
  185.  * No filter means accept all.
  186.  */
  187. return (u_int)-1;
  188. A = 0;
  189. X = 0;
  190. --pc;
  191. while (1) {
  192. ++pc;
  193. switch (pc->code) {
  195. default:
  196. return 0;
  197. case BPF_RET|BPF_K:
  198. return (u_int)pc->k;
  200. case BPF_RET|BPF_A:
  201. return (u_int)A;
  203.                 case BPF_RET|BPF_K|BPF_HLEN:
  204.                         return (u_int)(pc->k + offset);
  206. case BPF_LD|BPF_W|BPF_ABS:
  207. k = pc->k;
  208. if (k + sizeof(int32) > buflen) {
  209. int merr;
  211. if (buflen != 0)
  212. return 0;
  213. A = m_xword((struct mbuf *)p, k, &merr);
  214. if (merr != 0)
  215. return 0;
  216. continue;
  217. }
  218. A = EXTRACT_LONG(&p[k]);
  219. continue;
  221. case BPF_LD|BPF_H|BPF_ABS:
  222. k = pc->k;
  223. if (k + sizeof(short) > buflen) {
  224. int merr;
  226. if (buflen != 0)
  227. return 0;
  228. A = m_xhalf((struct mbuf *)p, k, &merr);
  229. continue;
  230. }
  231. A = EXTRACT_SHORT(&p[k]);
  232. continue;
  234. case BPF_LD|BPF_B|BPF_ABS:
  235. k = pc->k;
  236. if (k >= buflen) {
  237. register struct mbuf *m;
  238. register int len;
  240. if (buflen != 0)
  241. return 0;
  242. m = (struct mbuf *)p;
  243. MINDEX(len, m, k);
  244. A = mtod(m, u_char *)[k];
  245. continue;
  246. }
  247. A = p[k];
  248. continue;
  250. case BPF_LD|BPF_W|BPF_ABS|BPF_HLEN:
  251. k = pc->k + offset;
  252. if (k + sizeof(int32) > buflen) {
  253. int merr;
  255. if (buflen != 0)
  256. return 0;
  257. A = m_xword((struct mbuf *)p, k, &merr);
  258. if (merr != 0)
  259. return 0;
  260. continue;
  261. }
  262. A = EXTRACT_LONG(&p[k]);
  263. continue;
  265. case BPF_LD|BPF_H|BPF_ABS|BPF_HLEN:
  266. k = pc->k + offset;
  267. if (k + sizeof(short) > buflen) {
  268. int merr;
  270. if (buflen != 0)
  271. return 0;
  272. A = m_xhalf((struct mbuf *)p, k, &merr);
  273. continue;
  274. }
  275. A = EXTRACT_SHORT(&p[k]);
  276. continue;
  278. case BPF_LD|BPF_B|BPF_ABS|BPF_HLEN:
  279. k = pc->k + offset;
  280. if (k >= buflen) {
  281. register struct mbuf *m;
  282. register int len;
  284. if (buflen != 0)
  285. return 0;
  286. m = (struct mbuf *)p;
  287. MINDEX(len, m, k);
  288. A = mtod(m, u_char *)[k];
  289. continue;
  290. }
  291. A = p[k];
  292. continue;
  294. case BPF_LD|BPF_W|BPF_LEN:
  295. A = wirelen;
  296. continue;
  298. case BPF_LDX|BPF_W|BPF_LEN:
  299. X = wirelen;
  300. continue;
  302. case BPF_LD|BPF_TYPE:
  303. A = type;
  304. continue;
  306. case BPF_LD|BPF_HLEN:
  307. A = offset;
  308. continue;
  310.                 case BPF_LDX|BPF_HLEN:
  311.                         X = offset;
  312.                         continue;
  314. case BPF_LD|BPF_W|BPF_IND:
  315. k = X + pc->k;
  316. if (k + sizeof(int32) > buflen) {
  317. int merr;
  319. if (buflen != 0)
  320. return 0;
  321. A = m_xword((struct mbuf *)p, k, &merr);
  322. if (merr != 0)
  323. return 0;
  324. continue;
  325. }
  326. A = EXTRACT_LONG(&p[k]);
  327. continue;
  329. case BPF_LD|BPF_H|BPF_IND:
  330. k = X + pc->k;
  331. if (k + sizeof(short) > buflen) {
  332. int merr;
  334. if (buflen != 0)
  335. return 0;
  336. A = m_xhalf((struct mbuf *)p, k, &merr);
  337. if (merr != 0)
  338. return 0;
  339. continue;
  340. }
  341. A = EXTRACT_SHORT(&p[k]);
  342. continue;
  344. case BPF_LD|BPF_B|BPF_IND:
  345. k = X + pc->k;
  346. if (k >= buflen) {
  347. register struct mbuf *m;
  348. register int len;
  350. if (buflen != 0)
  351. return 0;
  352. m = (struct mbuf *)p;
  353. MINDEX(len, m, k);
  354. A = mtod(m, u_char *)[k];
  355. continue;
  356. }
  357. A = p[k];
  358. continue;
  360. case BPF_LDX|BPF_MSH|BPF_B|BPF_HLEN:
  361. k = pc->k + offset;
  362. if (k >= buflen) {
  363. register struct mbuf *m;
  364. register int len;
  366. if (buflen != 0)
  367. return 0;
  368. m = (struct mbuf *)p;
  369. MINDEX(len, m, k);
  370. X = (mtod(m, char *)[k] & 0xf) << 2;
  371. continue;
  372. }
  373. X = (p[pc->k] & 0xf) << 2;
  374. continue;
  376. case BPF_LDX|BPF_MSH|BPF_B:
  377. k = pc->k;
  378. if (k >= buflen) {
  379. register struct mbuf *m;
  380. register int len;
  382. if (buflen != 0)
  383. return 0;
  384. m = (struct mbuf *)p;
  385. MINDEX(len, m, k);
  386. X = (mtod(m, char *)[k] & 0xf) << 2;
  387. continue;
  388. }
  389. X = (p[pc->k] & 0xf) << 2;
  390. continue;
  392. case BPF_LD|BPF_IMM:
  393. A = pc->k;
  394. continue;
  396. case BPF_LDX|BPF_IMM:
  397. X = pc->k;
  398. continue;
  400. case BPF_LD|BPF_MEM:
  401. A = mem[pc->k];
  402. continue;
  404. case BPF_LDX|BPF_MEM:
  405. X = mem[pc->k];
  406. continue;
  408. case BPF_ST:
  409. mem[pc->k] = A;
  410. continue;
  412. case BPF_STX:
  413. mem[pc->k] = X;
  414. continue;
  416. case BPF_JMP|BPF_JA:
  417. pc += pc->k;
  418. continue;
  420. case BPF_JMP|BPF_JGT|BPF_K:
  421. pc += (A > pc->k) ? pc->jt : pc->jf;
  422. continue;
  424. case BPF_JMP|BPF_JGE|BPF_K:
  425. pc += (A >= pc->k) ? pc->jt : pc->jf;
  426. continue;
  428. case BPF_JMP|BPF_JEQ|BPF_K:
  429. pc += (A == pc->k) ? pc->jt : pc->jf;
  430. continue;
  432. case BPF_JMP|BPF_JSET|BPF_K:
  433. pc += (A & pc->k) ? pc->jt : pc->jf;
  434. continue;
  436. case BPF_JMP|BPF_JGT|BPF_X:
  437. pc += (A > X) ? pc->jt : pc->jf;
  438. continue;
  440. case BPF_JMP|BPF_JGE|BPF_X:
  441. pc += (A >= X) ? pc->jt : pc->jf;
  442. continue;
  444. case BPF_JMP|BPF_JEQ|BPF_X:
  445. pc += (A == X) ? pc->jt : pc->jf;
  446. continue;
  448. case BPF_JMP|BPF_JSET|BPF_X:
  449. pc += (A & X) ? pc->jt : pc->jf;
  450. continue;
  452. case BPF_ALU|BPF_ADD|BPF_X:
  453. A += X;
  454. continue;
  456. case BPF_ALU|BPF_SUB|BPF_X:
  457. A -= X;
  458. continue;
  460. case BPF_ALU|BPF_MUL|BPF_X:
  461. A *= X;
  462. continue;
  464. case BPF_ALU|BPF_DIV|BPF_X:
  465. if (X == 0)
  466. return 0;
  467. A /= X;
  468. continue;
  470. case BPF_ALU|BPF_AND|BPF_X:
  471. A &= X;
  472. continue;
  474. case BPF_ALU|BPF_OR|BPF_X:
  475. A |= X;
  476. continue;
  478. case BPF_ALU|BPF_LSH|BPF_X:
  479. A <<= X;
  480. continue;
  482. case BPF_ALU|BPF_RSH|BPF_X:
  483. A >>= X;
  484. continue;
  486. case BPF_ALU|BPF_ADD|BPF_K:
  487. A += pc->k;
  488. continue;
  490. case BPF_ALU|BPF_SUB|BPF_K:
  491. A -= pc->k;
  492. continue;
  494. case BPF_ALU|BPF_MUL|BPF_K:
  495. A *= pc->k;
  496. continue;
  498. case BPF_ALU|BPF_DIV|BPF_K:
  499. A /= pc->k;
  500. continue;
  502. case BPF_ALU|BPF_AND|BPF_K:
  503. A &= pc->k;
  504. continue;
  506. case BPF_ALU|BPF_OR|BPF_K:
  507. A |= pc->k;
  508. continue;
  510. case BPF_ALU|BPF_LSH|BPF_K:
  511. A <<= pc->k;
  512. continue;
  514. case BPF_ALU|BPF_RSH|BPF_K:
  515. A >>= pc->k;
  516. continue;
  518. case BPF_ALU|BPF_NEG:
  519. A = -A;
  520. continue;
  522. case BPF_MISC|BPF_TAX:
  523. X = A;
  524. continue;
  526. case BPF_MISC|BPF_TXA:
  527. A = X;
  528. continue;
  529. }
  530. }
  531. }
  533. /*
  534.  * Return true if the 'fcode' is a valid filter program.
  535.  * The constraints are that each jump be forward and to a valid
  536.  * code.  The code must terminate with either an accept or reject. 
  537.  * 'valid' is an array for use by the routine (it must be at least
  538.  * 'len' bytes long).  
  539.  *
  540.  * The kernel needs to be able to verify an application's filter code.
  541.  * Otherwise, a bogus program could easily crash the system.
  542.  */
  543. int
  544. bpf_validate(f, len)
  545. struct bpf_insn *f;
  546. int len;
  547. {
  548. register int i;
  549. register struct bpf_insn *p;
  551. for (i = 0; i < len; ++i) {
  552. /*
  553.  * Check that that jumps are forward, and within 
  554.  * the code block.
  555.  */
  556. p = &f[i];
  557. if (BPF_CLASS(p->code) == BPF_JMP) {
  558. register int from = i + 1;
  560. if (BPF_OP(p->code) == BPF_JA) {
  561. if (from + p->k >= (unsigned)len)
  562. return 0;
  563. }
  564. else if (from + p->jt >= len || from + p->jf >= len)
  565. return 0;
  566. }
  567. /*
  568.  * Check that memory operations use valid addresses.
  569.  */
  570. if ((BPF_CLASS(p->code) == BPF_ST ||
  571.      (BPF_CLASS(p->code) == BPF_LD && 
  572.       (p->code & 0xe0) == BPF_MEM)) &&
  573.     (p->k >= BPF_MEMWORDS || p->k < 0))
  574. return 0;
  575. /*
  576.  * Check for constant division by 0.
  577.  */
  578. if (p->code == (BPF_ALU|BPF_DIV|BPF_K) && p->k == 0)
  579. return 0;
  580. }
  581. return BPF_CLASS(f[len - 1].code) == BPF_RET;
  582. }