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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
Agent.c
资源名称：SNMP_source.rar　[点击查看]
上传用户：lvjun8202
上传日期：2013-04-30
资源大小：797k
文件大小：25k
源码类别：

SNMP编程

开发平台：

C/C++

Agent.c：源码内容
  1. #include <lljgeneral.h>
  3. /* globals */
  4. extern xdata mib_object_t *MibRoot;
  5. extern xdata union netcard rxdnet;
  6. extern xdata union netcard txdnet;
  8. u32 snmpAuthEnable = AGENT_AUTH_DISABLE; /* enable/disable snmp authentication */
  10. /* space allocated for snmp hosts/communities for authentication purposes */
  11. struct snmpComm_t authComms[AUTH_MAX_COMMS]; /* space for all communities allowed */
  12. struct snmpHost_t authHosts[AUTH_MAX_HOSTS]; /* space for all hosts allowed       */
  14. /* space allocated for snmp hosts/communities for traps */
  15. struct snmpComm_t trapComms[TRAP_MAX_COMMS]; /* space for all communities allowed */
  16. struct snmpHost_t trapHosts[TRAP_MAX_HOSTS]; /* space for all hosts allowed       */
  18. u32 snmpAuthMaxComms = AUTH_MAX_COMMS; /* max communities for auth group */
  19. u32 snmpAuthMaxHosts = AUTH_MAX_HOSTS; /* max hosts for auth group       */
  20. u32 snmpTrapMaxComms = TRAP_MAX_COMMS; /* max communities for trap group */
  21. u32 snmpTrapMaxHosts = TRAP_MAX_HOSTS; /* max hosts for trap group       */
  23. /**************************************************
  24. SNMP proc parameters
  25. **************************************************/
  27. xdata system_t system;
  28. xdata txfxDevice_t txfxDevice;
  29. xdata txfxModule_t modules[MAX_MOUDLE_NUM];
  31. // insert here SNMP modules in order to find the faults
  33. /* defines */
  35. #define SNMP_IPA    0 /* Ipaddress, APPLICATION (0) */
  36. #define SNMP_CNT    1 /* Counter,   APPLICATION (1) */
  37. #define SNMP_GGE    2 /* Gauge,     APPLICATION (2) */
  38. #define SNMP_TIT    3 /* TimeTicks  APPLICATION (3) */
  39. #define SNMP_OPQ    4 /* Opaque,    APPLICATION (4) */
  41. /* typedefs */
  43. typedef struct snmp_cnv_s snmp_cnv_t;
  45. struct snmp_cnv_s
  46. {
  47. u32 Class;
  48. u32 Tag;
  49. i32 Syntax;
  50. };
  52. /* globals */
  54. i32 snmpErrStatus = SNMP_NOERROR;
  55. i32 snmpErrIndex = 0;
  57. asn1_sck_t snmpErrAsn1Status;
  58. asn1_sck_t snmpErrAsn1Index;
  59. asn1_sck_t snmpErrAsn1Resp;
  61. snmp_stat_t SnmpStat;
  63. const i8 *SnmpTrap[] =
  64. {
  65. "cold start",
  66. "warm start",
  67. "link down",
  68. "link up",
  69. "authentication failure",
  70. "neighbor loss",
  71. "enterprise specific"
  72. };
  74. /* locals */
  76. static snmp_cnv_t SnmpCnv[] =
  77. {
  78. {ASN1_UNI, ASN1_NUL, SNMP_NULL},
  79. {ASN1_UNI, ASN1_INT, SNMP_INTEGER},
  80. {ASN1_UNI, ASN1_OTS, SNMP_OCTETSTR},
  81. {ASN1_UNI, ASN1_OTS, SNMP_DISPLAYSTR},
  82. {ASN1_UNI, ASN1_OJI, SNMP_OBJECTID},
  83. {ASN1_APL, SNMP_IPA, SNMP_IPADDR},
  84. {ASN1_APL, SNMP_CNT, SNMP_COUNTER},
  85. {ASN1_APL, SNMP_GGE, SNMP_GAUGE},
  86. {ASN1_APL, SNMP_TIT, SNMP_TIMETICKS},
  87. {ASN1_APL, SNMP_OPQ, SNMP_OPAQUE},
  88. {0, 0, -1}
  89. };
  91. /* forward declarations */
  93. static int SnmpSyn2TagCls(u32 * Tag, u32 * Cls, i32 Syn);
  94. static int SnmpTagCls2Syn(u32 Tag, u32 Cls, u16 * Syn);
  95. static int SnmpObjEnc(asn1_sck_t * Asn1, snmp_object_t * Obj);
  96. static int SnmpObjDec(asn1_sck_t * Asn1, snmp_object_t * Obj);
  97. static int SnmpLstEnc(asn1_sck_t * Asn1, snmp_object_t * Lst, u32 LstLen);
  98. static int SnmpLstDec(asn1_sck_t * Asn1, snmp_object_t * Lst, u32 LstSze, u32 * LstLen);
  99. static int SnmpRqsEnc(asn1_sck_t * Asn1, snmp_pdu_t * Rqs);
  100. static int SnmpRqsDec(asn1_sck_t * Asn1, snmp_pdu_t * Rqs);
  101. static int SnmpPduEnc(asn1_sck_t * Asn1, snmp_pdu_t * Pdu, snmp_object_t * Lst, u32 LstLen);
  102. static int SnmpPduDec(asn1_sck_t * Asn1, snmp_pdu_t * Pdu, snmp_object_t * Lst, u32 LstSze, u32 * LstLen);
  105. int SnmpSyn2TagCls
  106.     (
  107.     u32 * Tag, 
  108.     u32 * Cls, 
  109.     i32   Syn
  110.     )
  111. {
  112. snmp_cnv_t *Cnv;
  114. Cnv = SnmpCnv;
  115. while (Cnv->Syntax != -1)
  116. {
  117. if (Cnv->Syntax == Syn)
  118. {
  119. *Tag = Cnv->Tag;
  120. *Cls = Cnv->Class;
  121. return TRUE;
  122. }
  123. Cnv++;
  124. }
  125. snmpErrStatus = SNMP_BADVALUE;
  126. SnmpStat.OutBadValues++;
  127. return FALSE;
  128. }
  131. int SnmpTagCls2Syn
  132.     (
  133.     u32   Tag, 
  134.     u32   Cls, 
  135.     u16 * Syn
  136.     )
  137. {
  138. snmp_cnv_t *Cnv;
  140. Cnv = SnmpCnv;
  141. while (Cnv->Syntax != -1)
  142. {
  143. if (Cnv->Tag == Tag && Cnv->Class == Cls)
  144. {
  145. *Syn = (u16) Cnv->Syntax;
  146. return TRUE;
  147. }
  148. Cnv++;
  149. }
  150. snmpErrStatus = SNMP_BADVALUE;
  151. SnmpStat.OutBadValues++;
  152. return FALSE;
  153. }
  156. int SnmpObjEnc
  157.     (
  158.     asn1_sck_t *    Asn1, 
  159.     snmp_object_t * Obj
  160.     )
  161. {
  162. u32 Cls, Tag;
  163. u8 *Eoc, *End;
  165. if (!Asn1EocEnc(Asn1, &Eoc))
  166. {
  167. return FALSE;
  168. }
  169. switch (Obj->Type)
  170. {
  171. case SNMP_INTEGER:
  172. if (!Asn1IntEncLng(Asn1, &End, Obj->Syntax.LngInt))
  173. {
  174. return FALSE;
  175. }
  176. break;
  177. case SNMP_OCTETSTR:
  178. case SNMP_OPAQUE:
  179. if (!Asn1OtsEnc(Asn1, &End, Obj->Syntax.BufChr, Obj->SyntaxLen))
  180. {
  181. return FALSE;
  182. }
  183. break;
  184. case SNMP_NULL:
  185. if (!Asn1NulEnc(Asn1, &End))
  186. {
  187. return FALSE;
  188. }
  189. break;
  190. case SNMP_OBJECTID:
  191. if (!Asn1OjiEnc(Asn1, &End, (u32 *) Obj->Syntax.BufInt, Obj->SyntaxLen))
  192. {
  193. return FALSE;
  194. }
  195. break;
  196. case SNMP_IPADDR:
  197. if (!Asn1OtsEnc(Asn1, &End, (u8 *) & Obj->Syntax.LngUns, 4))
  198. {
  199. return FALSE;
  200. }
  201. break;
  202. case SNMP_COUNTER:
  203. case SNMP_GAUGE:
  204. case SNMP_TIMETICKS:
  205. if (!Asn1IntEncLngUns(Asn1, &End, Obj->Syntax.LngUns))
  206. {
  207. return FALSE;
  208. }
  209. break;
  210. default:
  211. snmpErrStatus = SNMP_BADVALUE;
  212. SnmpStat.OutBadValues++;
  213. return FALSE;
  214. }
  215. if (!SnmpSyn2TagCls(&Tag, &Cls, Obj->Type))
  216. {
  217. return FALSE;
  218. }
  219. if (!Asn1HdrEnc(Asn1, End, Cls, ASN1_PRI, Tag))
  220. {
  221. return FALSE;
  222. }
  223. if (!Asn1OjiEnc(Asn1, &End, (u32 *) Obj->Id, Obj->IdLen))
  224. {
  225. return FALSE;
  226. }
  227. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OJI))
  228. {
  229. return FALSE;
  230. }
  231. if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  232. {
  233. return FALSE;
  234. }
  235. return TRUE;
  236. }
  239. int SnmpObjDec
  240.     (
  241.     asn1_sck_t *    Asn1, 
  242.     snmp_object_t * Obj
  243.     )
  244. {
  245. u32 Cls, Con, Tag;
  246. u8 *Eoc, *End;
  248. if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
  249. return FALSE;
  250. if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  251. return FALSE;
  252. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  253. return FALSE;
  254. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OJI)
  255. return FALSE;
  256. if (!Asn1OjiDec(Asn1, End, (u32 *) Obj->Id, SNMP_SIZE_OBJECTID, &Obj->IdLen))
  257. return FALSE;
  258. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  259. return FALSE;
  260. if (Con != ASN1_PRI)
  261. {
  262. snmpErrStatus = SNMP_BADVALUE;
  263. SnmpStat.OutBadValues++;
  264. return FALSE;
  265. }
  266. if (!SnmpTagCls2Syn(Tag, Cls, &Obj->Type))
  267. return FALSE;
  268. switch (Obj->Type)
  269. {
  270. case SNMP_INTEGER:
  271. if (!Asn1IntDecLng(Asn1, End, (i32 *) & Obj->Syntax.LngInt))
  272. return FALSE;
  273. break;
  274. case SNMP_OCTETSTR:
  275. case SNMP_OPAQUE:
  276. if (!Asn1OtsDec(Asn1, End, Obj->Syntax.BufChr, SNMP_SIZE_BUFCHR,
  277. &Obj->SyntaxLen))
  278. return FALSE;
  279. break;
  280. case SNMP_NULL:
  281. if (!Asn1NulDec(Asn1, End))
  282. return FALSE;
  283. break;
  284. case SNMP_OBJECTID:
  285. if (!Asn1OjiDec(Asn1, End, (u32 *) Obj->Syntax.BufInt, SNMP_SIZE_BUFINT,
  286. &Obj->SyntaxLen))
  287. return FALSE;
  288. break;
  289. case SNMP_IPADDR:
  290. if (!Asn1OtsDec(Asn1, End, (u8 *) & Obj->Syntax.LngUns, 4,
  291. &Obj->SyntaxLen))
  292. return FALSE;
  293. if (Obj->SyntaxLen != 4)
  294. return FALSE;
  295. break;
  296. case SNMP_COUNTER:
  297. case SNMP_GAUGE:
  298. case SNMP_TIMETICKS:
  299. if (!Asn1IntDecLngUns(Asn1, End, (u32 *) & Obj->Syntax.LngUns))
  300. return FALSE;
  301. break;
  302. default:
  303. snmpErrStatus = SNMP_BADVALUE;
  304. SnmpStat.OutBadValues++;
  305. return FALSE;
  306. }
  307. if (!Asn1EocDec(Asn1, Eoc))
  308. return FALSE;
  309. return TRUE;
  310. }
  313. int SnmpLstEnc
  314.     (
  315.     asn1_sck_t *    Asn1, 
  316.     snmp_object_t * Lst, 
  317.     u32             LstLen
  318.     )
  319. {
  320. u8 *Eoc;
  322. if (!Asn1EocEnc(Asn1, &Eoc))
  323. {
  324. return FALSE;
  325. }
  326. Lst += LstLen;
  327. while (LstLen-- > 0)
  328. {
  329. if (!SnmpObjEnc(Asn1, --Lst))
  330. {
  331. return FALSE;
  332. }
  333. }
  334. if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  335. {
  336. return FALSE;
  337. }
  338. return TRUE;
  339. }
  342. int SnmpLstDec
  343.     (
  344.     asn1_sck_t *    Asn1, 
  345.     snmp_object_t * Lst, 
  346.     u32             LstSze, 
  347.     u32 *           LstLen
  348.     )
  349. {
  350. u32 Cls, Con, Tag;
  351. u8 *Eoc;
  353. if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
  354. return FALSE;
  355. if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  356. return FALSE;
  357. *LstLen = 0;
  358. while (!Asn1Eoc(Asn1, Eoc))
  359. {
  360. if (++(*LstLen) > LstSze)
  361. {
  362. snmpErrStatus = SNMP_TOOBIG;
  363. SnmpStat.OutTooBigs++;
  364. return FALSE;
  365. }
  366. if (!SnmpObjDec(Asn1, Lst++))
  367. {
  368. snmpErrIndex = (i32) * LstLen;
  369. return FALSE;
  370. }
  371. }
  372. if (!Asn1EocDec(Asn1, Eoc))
  373. return FALSE;
  374. return TRUE;
  375. }
  377. int SnmpRqsEnc
  378.     (
  379.     asn1_sck_t *     Asn1, 
  380.     snmp_pdu_t * Rqs
  381.     )
  382. {
  383. u8 *End;
  385. if (!Asn1IntEncUns(Asn1, &End, Rqs->ErrorIndex))
  386. return FALSE;
  387. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  388. return FALSE;
  389. if (!Asn1IntEncUns(Asn1, &End, Rqs->ErrorStatus))
  390. return FALSE;
  391. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  392. return FALSE;
  393. if (!Asn1IntEncLngUns(Asn1, &End, Rqs->Id))
  394. return FALSE;
  395. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  396. return FALSE;
  397. return TRUE;
  398. }
  401. int SnmpRqsDec
  402.     (
  403.     asn1_sck_t *     Asn1, 
  404.     snmp_pdu_t * Rqs
  405.     )
  406. {
  407. u32 Cls, Con, Tag;
  408. u8 *End;
  410. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  411. return FALSE;
  412. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  413. return FALSE;
  414. if (!Asn1IntDecLngUns(Asn1, End, (u32 *) & Rqs->Id))
  415. return FALSE;
  416. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  417. return FALSE;
  418. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  419. return FALSE;
  420. if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorStatus))
  421. return FALSE;
  422. memcpy(&snmpErrAsn1Status, Asn1, sizeof(asn1_sck_t));
  423. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  424. return FALSE;
  425. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  426. return FALSE;
  427. if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorIndex))
  428. return FALSE;
  429. /*
  430.  * Should not receive any error status
  431.  */
  432. if (Rqs->ErrorStatus != SNMP_NOERROR)
  433. {
  434. switch (Rqs->ErrorStatus)
  435. {
  436. case SNMP_TOOBIG:
  437. SnmpStat.InTooBigs++;
  438. break;
  439. case SNMP_NOSUCHNAME:
  440. SnmpStat.InNoSuchNames++;
  441. break;
  442. case SNMP_BADVALUE:
  443. SnmpStat.InBadValues++;
  444. break;
  445. case SNMP_READONLY:
  446. SnmpStat.InReadOnlys++;
  447. break;
  448. default:
  449. SnmpStat.InGenErrs++;
  450. break;
  451. }
  452. return FALSE;
  453. }
  454. #if 0
  455. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  456. return FALSE;
  457. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  458. return FALSE;
  459. if (!Asn1IntDecUns(Asn1, End, &Rqs->ErrorIndex))
  460. return FALSE;
  461. #endif
  462. memcpy(&snmpErrAsn1Index, Asn1, sizeof(asn1_sck_t));
  463. return TRUE;
  464. }
  467. int SnmpPduEnc
  468.     (
  469.     asn1_sck_t *    Asn1, 
  470.     snmp_pdu_t *    Pdu, 
  471.     snmp_object_t * Lst, 
  472.     u32             LstLen
  473.     )
  474. {
  475. u8 *Eoc;
  477. if (!Asn1EocEnc(Asn1, &Eoc))
  478. {
  479. return FALSE;
  480. }
  481. if (!SnmpLstEnc(Asn1, Lst, LstLen))
  482. {
  483. return FALSE;
  484. }
  485. switch (Pdu->Type)
  486. {
  487. case SNMP_PDU_GET:
  488. case SNMP_PDU_NEXT:
  489. case SNMP_PDU_RESPONSE:
  490. case SNMP_PDU_SET:
  491. case SNMP_PDU_TRAP:
  492. if (!SnmpRqsEnc(Asn1, Pdu))
  493. {
  494. return FALSE;
  495. }
  496. break;
  498. default:
  499. return FALSE;
  500. }
  501. if (!Asn1HdrEnc(Asn1, Eoc, ASN1_CTX, ASN1_CON, Pdu->Type))
  502. {
  503. return FALSE;
  504. }
  505. return TRUE;
  506. }
  509. int SnmpPduDec
  510.     (
  511.     asn1_sck_t *    Asn1, 
  512.     snmp_pdu_t *    Pdu, 
  513.     snmp_object_t * Lst, 
  514.     u32             LstSze, 
  515.     u32 *           LstLen
  516.     )
  517. {
  518. u32 Cls, Con;
  519. u8 *Eoc;
  521. if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Pdu->Type))
  522. return FALSE;
  524. memcpy(&snmpErrAsn1Resp, Asn1, sizeof(asn1_sck_t));
  526. if (Cls != ASN1_CTX || Con != ASN1_CON)
  527. return FALSE;
  528. switch (Pdu->Type)
  529. {
  530. case SNMP_PDU_GET:
  531. case SNMP_PDU_NEXT:
  532. case SNMP_PDU_RESPONSE:
  533. case SNMP_PDU_SET:
  534. case SNMP_PDU_TRAP:
  535. if (!SnmpRqsDec(Asn1, Pdu))
  536. return FALSE;
  537. break;
  538. default:
  539. SnmpStat.InBadTypes++;
  540. return FALSE;
  541. }
  542. if (!SnmpLstDec(Asn1, Lst, LstSze, LstLen))
  543. return FALSE;
  544. if (!Asn1EocDec(Asn1, Eoc))
  545. return FALSE;
  546. return TRUE;
  547. }
  550. int SnmpMsgEnc
  551.     (
  552.     asn1_sck_t *    Asn1, 
  553.     snmp_pdu_t *    Pdu, 
  554.     u8 *            Com, 
  555.     u32             ComLen, 
  556.     snmp_object_t * Lst, 
  557.     u32             LstLen
  558.     )
  559. {
  560. u8 *Eoc, *End;
  562. if (!Asn1EocEnc(Asn1, &Eoc))
  563. {
  564. return FALSE;
  565. }
  566. if (!SnmpPduEnc(Asn1, Pdu, Lst, LstLen))
  567. {
  568. return FALSE;
  569. }
  570. if (!Asn1OtsEnc(Asn1, &End, Com, ComLen))
  571. {
  572. return FALSE;
  573. }
  574. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_OTS))
  575. {
  576. return FALSE;
  577. }
  578. if (!Asn1IntEncUns(Asn1, &End, SNMP_VERSION))
  579. {
  580. return FALSE;
  581. }
  582. if (!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  583. {
  584. return FALSE;
  585. }
  586. if (!Asn1HdrEnc(Asn1, Eoc, ASN1_UNI, ASN1_CON, ASN1_SEQ))
  587. {
  588. return FALSE;
  589. }
  590. return TRUE;
  591. }
  594. int SnmpMsgDec
  595.     (
  596.     asn1_sck_t *    Asn1, 
  597.     snmp_pdu_t *    Pdu, 
  598.     u8 *            Com, 
  599.     u32             ComSze, 
  600.     u32 *           ComLen, 
  601.     snmp_object_t * Lst, 
  602.     u32             LstSze, 
  603.     u32 *           LstLen
  604.     )
  605. {
  606. u32 Cls, Con, Tag, Ver;
  607. u8 *Eoc, *End;
  609. if (!Asn1HdrDec(Asn1, &Eoc, &Cls, &Con, &Tag))
  610. {
  611. return FALSE;
  612. }
  613. if (Cls != ASN1_UNI || Con != ASN1_CON || Tag != ASN1_SEQ)
  614. {
  615. return FALSE;
  616. }
  617. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  618. {
  619. return FALSE;
  620. }
  621. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_INT)
  622. {
  623. return FALSE;
  624. }
  625. if (!Asn1IntDecUns(Asn1, End, &Ver))
  626. {
  627. return FALSE;
  628. }
  629. if (!Asn1HdrDec(Asn1, &End, &Cls, &Con, &Tag))
  630. {
  631. return FALSE;
  632. }
  633. if (Cls != ASN1_UNI || Con != ASN1_PRI || Tag != ASN1_OTS)
  634. {
  635. return FALSE;
  636. }
  637. if (!Asn1OtsDec(Asn1, End, Com, ComSze, ComLen))
  638. {
  639. return FALSE;
  640. }
  641. if (Ver != SNMP_VERSION)
  642. {
  643. SnmpStat.InBadVersions++;
  644. return FALSE;
  645. }
  646. if (!SnmpPduDec(Asn1, Pdu, Lst, LstSze, LstLen))
  647. {
  648. return FALSE;
  649. }
  650. if (!Asn1EocDec(Asn1, Eoc))
  651. {
  652. return FALSE;
  653. }
  654. return TRUE;
  655. }
  658. int SnmpEnc
  659.     (
  660.     u8 **           Snmp, 
  661.     u32 *           SnmpLen, 
  662.     snmp_pdu_t *    Pdu, 
  663.     u8 *            Com, 
  664.     u32             ComLen, 
  665.     snmp_object_t * Lst, 
  666.     u32             LstLen
  667.     )
  668. {
  669. static asn1_sck_t SnmpEncAsn1;
  671. snmpErrStatus = SNMP_NOERROR;
  672. snmpErrIndex = 0;
  674. Asn1Opn(&SnmpEncAsn1, *Snmp, *SnmpLen, ASN1_ENC);
  675. if (!SnmpMsgEnc(&SnmpEncAsn1, Pdu, Com, ComLen, Lst, LstLen))
  676. {
  678. if (snmpErrStatus == SNMP_NOERROR)
  679. {
  680. switch (asn1ErrStatus)
  681. {
  682. case ASN1_ERR_ENC_FULL:
  683. case ASN1_ERR_NOERROR:
  684. case ASN1_ERR_DEC_EMPTY:
  685. case ASN1_ERR_DEC_EOC_MISMATCH:
  686. case ASN1_ERR_DEC_LENGTH_MISMATCH:
  687. case ASN1_ERR_DEC_BADVALUE:
  688. case ASN1_ERR_ENC_BADVALUE:
  689. default:
  690. //PrintStr("rnSnmpEnc: GENERROR, asn1ErrStatus = %d", asn1ErrStatus);
  691. snmpErrStatus = SNMP_GENERROR;
  692. SnmpStat.OutGenErrs++;
  693. break;
  695. }
  696. }
  697. return FALSE;
  698. }
  700. Asn1Cls(&SnmpEncAsn1, Snmp, SnmpLen);
  702. SnmpStat.OutPkts++;
  704. switch (Pdu->Type)
  705. {
  706. case SNMP_PDU_GET:
  707. SnmpStat.OutGetRequests++;
  708. break;
  709. case SNMP_PDU_NEXT:
  710. SnmpStat.OutGetNexts++;
  711. break;
  712. case SNMP_PDU_RESPONSE:
  713. SnmpStat.OutGetResponses++;
  714. break;
  715. case SNMP_PDU_SET:
  716. SnmpStat.OutSetRequests++;
  717. break;
  718. case SNMP_PDU_TRAP:
  719. SnmpStat.OutTraps++;
  720. break;
  721. default:
  722. break;
  723. }
  725. return TRUE;
  726. }
  730. int SnmpDec
  731.     (
  732.     u8 *            Snmp, 
  733.     u32             SnmpLen, 
  734.     snmp_pdu_t *    Pdu, 
  735.     u8 *            Com, 
  736.     u32             ComSze, 
  737.     u32 *           ComLen, 
  738.     snmp_object_t * Lst, 
  739.     u32             LstSze, 
  740.     u32 *           LstLen
  741.     )
  742. {
  743. static asn1_sck_t SnmpDecAsn1;
  745. snmpErrStatus = SNMP_NOERROR;
  746. snmpErrIndex = 0;
  748. Asn1Opn(&SnmpDecAsn1, Snmp, SnmpLen, ASN1_DEC);
  749. if (!SnmpMsgDec(&SnmpDecAsn1, Pdu, Com, ComSze, ComLen, Lst, LstSze, LstLen))
  750. {
  751. if (snmpErrStatus == SNMP_NOERROR)
  752. {
  753. switch (asn1ErrStatus)
  754. {
  755. case ASN1_ERR_DEC_BADVALUE:
  756. case ASN1_ERR_DEC_EOC_MISMATCH:
  757. case ASN1_ERR_DEC_LENGTH_MISMATCH:
  758. case ASN1_ERR_DEC_EMPTY:
  759. snmpErrStatus = SNMP_BADVALUE;
  760. SnmpStat.OutBadValues++;
  761. SnmpStat.InASNParseErrs++;
  762. break;
  763. case ASN1_ERR_ENC_FULL:
  764. case ASN1_ERR_NOERROR:
  765. case ASN1_ERR_ENC_BADVALUE:
  766. default:
  767. snmpErrStatus = SNMP_GENERROR;
  768. SnmpStat.OutGenErrs++;
  769. break;
  770. }
  771. }
  772. return FALSE;
  773. }
  775. Asn1Cls(&SnmpDecAsn1, &Snmp, &SnmpLen);
  777. SnmpStat.InPkts++;
  778. switch (Pdu->Type)
  779. {
  780. case SNMP_PDU_GET:
  781. SnmpStat.InGetRequests++;
  782. break;
  783. case SNMP_PDU_NEXT:
  784. SnmpStat.InGetNexts++;
  785. break;
  786. case SNMP_PDU_RESPONSE:
  787. SnmpStat.InGetResponses++;
  788. break;
  789. case SNMP_PDU_SET:
  790. SnmpStat.InSetRequests++;
  791. break;
  792. case SNMP_PDU_TRAP:
  793. SnmpStat.InTraps++;
  794. break;
  795. default:
  796. break;
  797. }
  799. return TRUE;
  800. }
  804. int SnmpErrEnc
  805.     (
  806.     snmp_pdu_t * Rqs
  807.     )
  808. {
  809. u8 *End;
  810. /* asn1_sck_t *Asn1 = &snmpErrAsn1; */
  812. if (!Asn1IntEncUns(&snmpErrAsn1Index, &End, Rqs->ErrorIndex))
  813. return FALSE;
  814. if (!Asn1HdrEnc(&snmpErrAsn1Index, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  815. return FALSE;
  817. if (!Asn1IntEncUns(&snmpErrAsn1Status, &End, Rqs->ErrorStatus))
  818. return FALSE;
  819. if (!Asn1HdrEnc(&snmpErrAsn1Status, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  820. return FALSE;
  822. /*    if(!Asn1IntEncLngUns(&snmpErrAsn1Status, &End, Rqs->Id))
  823.  * return FALSE;
  824.  * if(!Asn1HdrEnc(Asn1, End, ASN1_UNI, ASN1_PRI, ASN1_INT))
  825.  * return FALSE; 
  826.  */
  828. if (!Asn1HdrEnc(&snmpErrAsn1Resp, snmpErrAsn1Resp.End, ASN1_CTX, ASN1_CON, Rqs->Type))
  829. return FALSE;
  830. return TRUE;
  831. }
  834. // all above from SNMP.c file
  835. static 
  836. int MsgRequest(u8 * rqsBuffer, u32 rqsLen,u8 ** rspBuffer,u32 * rspLen,ul32  addr);
  838. void dword2mem
  839.     (
  840.     u8 * mem, 
  841.     ul32 val
  842.     )
  843. {
  844. *(ul32 *) mem = val;
  845. }
  847. void bzero(u8* str, i32 len)
  848. {
  849. i32 i;
  850. for(i=0;i<len-1;i++)
  851. {
  852. str[i] = 0;
  853. }
  854. }
  857. STATUS initAgentTables()
  858. {
  859. u32 i;
  861. for (i = 0; i < AUTH_MAX_COMMS; i++)
  862. {
  863. authComms[i].index = i;
  864. authComms[i].name[0] = '';;
  865. authComms[i].access = AGENT_READ_ONLY;
  866. authComms[i].traps = 0;
  867. authComms[i].state = AGENT_VAL_INVALID;
  868. }
  870. for (i = 0; i < AUTH_MAX_HOSTS; i++)
  871. {
  872. authHosts[i].index = i;
  873. authHosts[i].name[0] = '';;
  874. authHosts[i].commName[0] = '';;
  875. authHosts[i].addr = 0;
  876. authHosts[i].mask = 0xffffff00;
  877. authHosts[i].state = AGENT_VAL_INVALID;
  878. }
  880. for (i = 0; i < TRAP_MAX_COMMS; i++)
  881. {
  882. trapComms[i].index = i;
  883. trapComms[i].name[0] = '';;
  884. trapComms[i].access = AGENT_READ_ONLY;
  885. trapComms[i].traps = 0;
  886. trapComms[i].state = AGENT_VAL_INVALID;
  887. }
  889. for (i = 0; i < TRAP_MAX_HOSTS; i++)
  890. {
  891. trapHosts[i].index = i;
  892. trapHosts[i].name[0] = '';;
  893. trapHosts[i].commName[0] = '';;
  894. trapHosts[i].addr = 0;
  895. trapHosts[i].mask = 0xffffff00;
  896. trapHosts[i].state = AGENT_VAL_INVALID;
  897. }
  898. return OK;
  899. }
  902. int authCommFind
  903.     (
  904.     char * name
  905.     )
  906. {
  907. int i;
  908. for(i=0; i<snmpAuthMaxComms; i++)
  909. {
  910. if (strcmp(authComms[i].name, name) == 0)
  911. {
  912. if (authComms[i].state == AGENT_VAL_ENABLE)
  913. return i+1;
  914. else
  915. return 0;
  916. }
  918. }
  919. return 0;
  920. }
  923. STATUS authHostInComm
  924.     (   
  925. u8*  comm, 
  926.     ul32                 addr
  927.     )
  928. {
  929.  int i;
  930. for(i=0; i< snmpAuthMaxHosts; i++)
  931. {
  932. if ((authHosts[i].addr == addr)&&(!strcmp(authHosts[i].commName,comm)))
  933. {
  934. if (authHosts[i].state == AGENT_VAL_ENABLE)
  935. return OK;
  936. else
  937. return ERROR;
  938. }
  939. }
  940. return ERROR;
  941. }
  944. int trapCommFind
  945.     (
  946.     char * name
  947.     )
  948. {
  949. int i;
  950. for(i=0; i<snmpTrapMaxComms; i++)
  951. {
  952.   if (strcmp(trapComms[i].name, name) == 0)
  953. {
  954. if (trapComms[i].state == AGENT_VAL_ENABLE)
  955. return i+1;
  956. else
  957. return 0;
  958. }
  959. }
  960. return 0;
  961. }
  964. STATUS agentSnmpTrapSupport
  965.     (
  966.     u32   index, 
  967.     u32             snmpTrapType
  968.     )
  969. {
  970. switch (snmpTrapType)
  971. {
  972. case SNMP_TRAP_COLDSTART:
  973. if (trapComms[index].traps & AGENT_COLD_START)
  974. return OK;
  975. break;
  976. case SNMP_TRAP_LINKDOWN:
  977. if (trapComms[index].traps & AGENT_LINK_DOWN)
  978. return OK;
  979. break;
  980. case SNMP_TRAP_LINKUP:
  981. if (trapComms[index].traps & AGENT_LINK_UP)
  982. return OK;
  983. break;
  984. case SNMP_TRAP_AUTFAILURE:
  985. if (trapComms[index].traps & AGENT_AUTHEN)
  986. return OK;
  987. break;
  988. case SNMP_TRAP_ENTSPECIFIC:
  989. break;
  990. case SNMP_TRAP_EQPNEIGHBORLOSS:
  991. case SNMP_TRAP_WARMSTART:
  992. default:
  993. break;
  994. }
  995. return ERROR;
  996. }
  998. /**************************************************************************
  999. SNMP protocol procedures
  1000. ***************************************************************************/
  1002. int AgentSendTrap
  1003.     (
  1004.     u8 *            comm, 
  1005.     u16             commLen, 
  1006.     u16             gen, 
  1007.     snmp_object_t * list, 
  1008.     u16             listLen
  1009.     )
  1010. {
  1011. u8 *                 trapBuffer;
  1012. u32                  trapLen;
  1013. static u8            sendTrapBuffer[AGENT_BUFFER_SIZE];
  1014. static snmp_pdu_t    sendTrappdu;
  1015. int   descr;
  1016. int                 success = FALSE;
  1017. u16                  dummy;
  1018. int i;
  1019. if (MibRequest (listLen, list, &dummy) == SNMP_NOERROR)
  1020. {
  1022. sendTrappdu.Type = SNMP_PDU_TRAP;
  1023. comm[commLen] = '';
  1024. descr = trapCommFind (comm);
  1025. if (descr != 0)
  1026. {
  1027. if (agentSnmpTrapSupport (descr, gen) == ERROR)
  1028. {
  1029. return FALSE;
  1030. }
  1032. success = TRUE;
  1033. for (i=0; i<snmpTrapMaxHosts; i++)
  1034. { 
  1035. if ((!strcmp(trapHosts[i].commName, comm))&&(!trapHosts[i].addr) || (trapHosts[i].state != AGENT_VAL_ENABLE))
  1036. continue;
  1038. trapBuffer                 = sendTrapBuffer;
  1039. trapLen                    = sizeof(sendTrapBuffer);
  1041. if (SnmpEnc (&trapBuffer, &trapLen, &sendTrappdu, comm, commLen,
  1042.  list, listLen))
  1043. {   
  1044. // udp_request1(trapHosts[i].addr, 162,trapBuffer,trapLen);
  1045. }
  1046. }
  1048. }
  1049. }
  1050. return (success);
  1051. }
  1054. void SendENTTrap
  1055.     (
  1056.     u16             gen, 
  1057.     snmp_object_t * list, 
  1058.     u16             listLen
  1059.     )
  1060. {
  1061. char *               commName;
  1062. snmp_object_t snmpTrapObject[2];
  1063. int i;
  1064. static ul32 sysUpTime[]= {1, 3, 6, 1, 2, 1, 1, 3, 0};
  1065. static ul32 snmpTrapOID[] = {1, 3, 6, 1, 6, 3, 1, 4 ,1 , 0};
  1068. if(list ==0)
  1069. {
  1070. snmpTrapObject[0].Request = SNMP_PDU_GET;
  1071. memcpy(snmpTrapObject[0].Id, sysUpTime,sizeof(sysUpTime));
  1072. snmpTrapObject[0].IdLen = sizeof(sysUpTime)/sizeof(ul32);
  1073. snmpTrapObject[0].Type = SNMP_TIMETICKS;
  1075. snmpTrapObject[1].Request = SNMP_PDU_GET;
  1076. memcpy(snmpTrapObject[1].Id, snmpTrapOID,sizeof(snmpTrapOID));
  1077. snmpTrapObject[1].IdLen = sizeof(sysUpTime)/sizeof(ul32);
  1078. snmpTrapObject[1].Type = SNMP_OBJECTID;
  1079. list = & snmpTrapObject[0];
  1080. listLen = sizeof(snmpTrapObject);
  1081. }
  1083. for(i=0;i<snmpTrapMaxComms; i++)
  1084. {
  1085. if(trapComms[i].state==AGENT_VAL_ENABLE)
  1086. {
  1087. memcpy(commName,trapComms[i].name,sizeof(trapComms[i].name));
  1088. (void) AgentSendTrap(commName, (u16) strlen(commName),
  1089.  gen, list, listLen);
  1090. }
  1091. }
  1092. }
  1094. static int MsgRequest
  1095.     (
  1096.     u8 *  rqsBuffer, 
  1097.     u32   rqsLen, 
  1098.     u8 ** rspBuffer, 
  1099.     u32 * rspLen,
  1100.     ul32  addr)
  1101. {
  1102. static snmp_pdu_t     Requestpdu;
  1103. snmp_request_t *      rqs = &Requestpdu;
  1104. static u8             RequestComm[AGENT_COMMUNITY_SIZE];
  1105. u32                   commLen;
  1106. static snmp_object_t  RequestList[AGENT_LIST_SIZE]; 
  1107. u32                   listLen;
  1108. u16                   status;
  1109. u16                   aindex;
  1110. static u8             Requestaddress[4];
  1111. u32                   perm;
  1112. static u8             Requestbuf[64];
  1114. bzero((i8 *) Requestbuf, 64);  
  1115. bzero( (i8*)RequestList, sizeof(RequestList));
  1117. if (!SnmpDec(rqsBuffer, rqsLen, &Requestpdu, RequestComm,
  1118.  AGENT_COMMUNITY_SIZE, &commLen, RequestList,
  1119.  AGENT_LIST_SIZE, &listLen))
  1120. {
  1122. rqs->Type = SNMP_PDU_RESPONSE;
  1123. rqs->ErrorStatus = (u32) snmpErrStatus;
  1124. rqs->ErrorIndex = (u32) snmpErrIndex;
  1126. if (!SnmpErrEnc(rqs))
  1127. {
  1128. return (FALSE);
  1129. }
  1131. memcpy(*rspBuffer, rqsBuffer, rqsLen);
  1132. *rspLen = rqsLen;
  1133. return (TRUE);
  1134. }
  1136. if (Requestpdu.Type != SNMP_PDU_GET &&
  1137. Requestpdu.Type != SNMP_PDU_NEXT &&
  1138. Requestpdu.Type != SNMP_PDU_SET)
  1139. {
  1140. PrintStr("SNMP, unknown PDUn");
  1141. return (FALSE);
  1142. }
  1144. if (snmpAuthEnable == AGENT_AUTH_ENABLE)
  1145. {
  1146. int p=0;
  1147. RequestComm[commLen] = '';
  1148. p = authCommFind(RequestComm);
  1150. if (p)
  1151. perm = authComms[--p].access;
  1152. else
  1153. perm = 0;
  1155. if (perm == 0)
  1156. {
  1157. memcpy((i8 *) RequestComm, (i8 *) & Requestbuf[0], commLen);
  1158. SendENTTrap(SNMP_TRAP_AUTFAILURE, 0, 0);
  1159. return (FALSE);
  1160. }
  1161. if (authHostInComm(authComms[p].name, addr) == ERROR)
  1162. {
  1163. dword2mem(Requestaddress, (ul32)addr);
  1164. memcpy((i8 *) RequestComm, (i8 *) & Requestbuf[0], commLen);
  1165. SendENTTrap(SNMP_TRAP_AUTFAILURE, 0, 0);
  1166. return (FALSE);
  1167. }
  1168. switch (Requestpdu.Type)
  1169. {
  1170.     case SNMP_PDU_NEXT:
  1171.     case SNMP_PDU_GET:
  1173.     break;
  1174.     case SNMP_PDU_SET:
  1175.     if ((perm & (u16) MIB_WRITE) == 0)
  1176.     {
  1177.     SendENTTrap(SNMP_TRAP_AUTFAILURE,0, 0);
  1178.     return (FALSE);
  1179.     }
  1180.     break;
  1181.     default:
  1182.     break;
  1183. }
  1184. }
  1186. for (aindex = 0; aindex < listLen; aindex++)
  1187. {
  1188. RequestList[aindex].Request = (u16) Requestpdu.Type;
  1189. }
  1190. /* status = MibRequest(listLen, RequestList, &aindex);
  1192. if (status != SNMP_NOERROR)
  1193. {
  1194. rqs->Type = SNMP_PDU_RESPONSE;
  1195. rqs->ErrorStatus = status;
  1196. rqs->ErrorIndex = aindex;
  1198. if (!SnmpErrEnc(rqs))
  1199. {
  1200. return (FALSE);
  1201. }
  1203. memcpy(*rspBuffer, rqsBuffer, rqsLen);
  1204. *rspLen = rqsLen;
  1205. return (TRUE);
  1206. }
  1207. */
  1208. rqs->Type = SNMP_PDU_RESPONSE;
  1209. rqs->ErrorStatus = SNMP_NOERROR;
  1210. rqs->ErrorIndex = 0;
  1212. if (!SnmpEnc(rspBuffer, rspLen, &Requestpdu, RequestComm, commLen, RequestList, listLen))
  1213. {
  1214. rqs->Type = SNMP_PDU_RESPONSE;
  1215. rqs->ErrorStatus = (u32) snmpErrStatus;
  1216. rqs->ErrorIndex = (u32) snmpErrIndex;
  1218. if (!SnmpErrEnc(rqs))
  1219. {
  1220. return (FALSE);
  1221. }
  1223. memcpy(*rspBuffer, rqsBuffer, rqsLen);
  1224. *rspLen = rqsLen;
  1225. return (TRUE);
  1226. }
  1227. return (TRUE);
  1228. }
  1230. void snmpcycle()
  1231. {
  1232. ;//do nothing here
  1233. }
  1234. void udp_recv()
  1235. {
  1236. int status,i;
  1237. int rqsLen,rspLen;
  1238. char rspBuffer[AGENT_BUFFER_SIZE];
  1239. char rqsBuffer[AGENT_BUFFER_SIZE];
  1240. u8 * rsp = rspBuffer;
  1241. ul32 addr = rxdnet.ipframe.sourceip; //目标IP地址
  1242. int port = rxdnet.udpframe.sourceport; // 目的端口号
  1243. rqsLen = rxdnet.udpframe.length-8;
  1245. PrintStr("nSNMP Message begin");
  1247. PrintStr("nUDP: dest_Port=");
  1248. PrintWord(rxdnet.udpframe.destport);
  1250. PrintStr("  source_Port=");
  1251. PrintWord(rxdnet.udpframe.sourceport);
  1253. PrintStr("  length=");
  1254. PrintWord(rxdnet.udpframe.length);
  1256. for(i=0;i<rxdnet.udpframe.length-8;i++)//8 bytes udp head
  1257. {
  1258. PrintByte(rxdnet.udpframe.udpdata[i]);//udp数
  1259. rqsBuffer[i] = rxdnet.udpframe.udpdata[i];
  1260. }
  1261. rqsLen = rxdnet.udpframe.length-8;
  1263. status=MsgRequest(rqsBuffer,rqsLen,&rsp,&rspLen,addr);
  1264. if(status)
  1265. {
  1266. // udp_request(rsp, rspLen,addr, port); //发送UDP请求包
  1267.       PrintStr("Please send UDP request here");
  1269. }
  1270. else
  1271. {
  1272. PrintStr("SNMP request ERROR!");
  1273. //do nothing;向串口打印错误信息。
  1274. }
  1275. }