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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
snmp_command.c
资源名称：snmp.src.rar　[点击查看]
上传用户：cxs890
上传日期：2021-05-22
资源大小：347k
文件大小：102k
源码类别：

SNMP编程

开发平台：

C/C++

snmp_command.c：源码内容
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <assert.h>
  5. #include <sys/types.h>
  6. #include <libsys/misc.h>
  7. #include <ctype.h>
  8. #ifdef SWITCH
  9. #include <libvty/vty.h>
  10. #endif
  11. #include <libcmd/cmdparse.h>
  12. #include <libcmd/cmderror.h>
  13. #include <libcmd/argparse.h>
  14. #ifndef SWITCH
  15. #include <libcmd/cmdiface.h>
  16. #endif
  17. #include <ip/socket.h>
  18. #include <ip/netdb.h>
  19. #include <ip/inet.h>
  20. #ifdef SWITCH
  21. #include <ip/ip_misc.h>
  22. #endif
  23. #include <libsys/memory.h>
  24. #include <ip/ip_externs.h>
  25. #include "config.h"
  26. #include "types.h"
  27. #include "asn1.h"
  28. #include "snmp_vars.h"
  30. #include "config_struct.h"
  31. #include "snmp_command.h"
  32. #include "view.h"
  33. #include "mib.h"
  34. #include "snmp_debug.h"
  35. #include "agent_trap.h"
  36. /*** sun define for snmp trap-timeout ,because i move structure trap_sink to snmpd.h 2000.03.21 ***/
  37. #include "snmpd.h"
  38. #include "snmp_api.h"
  39. #include "vacm.h"
  40. #include "snmp.h"
  41. #include <snmp/snmp_util.h>
  42. /*#include "snmp_util.h"*/
  43. #include <snmplib/transform_oids.h>
  44. #include <snmplib/tools.h>
  45. #include <snmplib/callback.h>
  46. #include <snmplib/snmpusm.h>
  47. #include <snmplib/snmp-tc.h>
  48. #include <snmplib/snmpv3.h>
  49. #include <snmplib/keytools.h>
  50. #include <snmplib/scapi.h>
  52. #ifdef OS_VXWORKS
  53. extern int32 set_trace_flag(MODULE_TYPE module, uint32 debug_flag, void (*show_debug)(uint32), void (*no_debug)(), uint8 bStatus);
  54. #endif
  55. /*added by sxf*/
  56. /*in vacm_vars.c*/
  57. extern void vacm_parse_security (const char *, char *);
  58. extern void vacm_parse_group (const char *, char *);
  59. extern void vacm_parse_access (const char *, char *);
  60. extern void vacm_parse_view (const char *, char *);
  62. extern BOOL vacm_walkThrSecEntry (void (*thrMethod)(struct vacm_securityEntry*));
  63. extern struct vacm_securityEntry *vacm_FindSecEntryByCommName (char *);
  64. extern void vacm_DestroyCommunity (char*);
  65. extern void vacm_DestroyCommunityAll (void);
  66. extern int createV1TrapSession (char *sink,char * com,unsigned short trapflags, char *vrfname);
  67. extern void set_trapsinks(int cmd,long long value);
  68. extern u_char * translate_objid(u_char *buf);
  69. extern char *snmp_ntoa (long );
  71. /*in vacm.c*/
  72. BOOL vacm_walkThrViewEntry (void (*thrMethod)(struct vacm_viewEntry*));
  74. /*in agent_registry.c*/
  75. BOOL ReadObjidFromSubtree (char *str, oid name[], int *name_len);
  77. /*** sun define end ***/
  79. static int dosnmp_community(int argc,char *argv[],struct user *u);
  81. #ifdef INCLUDE_SNMPV3
  82. static int dosnmp_group(int argc,char *argv[],struct user *u);
  83. static int dosnmp_user(int argc,char *argv[],struct user *u);
  84. #endif
  85. extern int delete_v1_trap_session(char *peer, char *community);
  88. long snmp_showrunning(DEVICE_ID diID);
  90. static int dosnmp_contact(int argc,char *argv[],struct user *u);
  91. #if 0
  92. static int dosnmp_contact_name(int argc,char *argv[],struct user *u);
  93. #endif
  94. void display_snmp_contact(void);
  96. static int dosnmp_location(int argc,char *argv[],struct user *u);
  97. static int dosnmp_location_name(int argc,char *argv[],struct user *u);
  98. void display_snmp_location(void);
  100. static int dosnmp_packetsize(int argc,char *argv[],struct user *u);
  101. static int dosnmp_queuelen(int argc,char *argv[],struct user *u);
  102. static int dosnmp_trap_source(int argc,char *argv[],struct user *u);
  103. static int dosnmp_trap_timeout(int argc,char *argv[],struct user *u);
  107. static int dosnmp_host(int argc,char *argv[],struct user *u);
  108.  /*** sun define 2000.03.16 ***/
  109. static int dosnmp_view(int argc,char *argv[],struct user *u);
  110. /*** sun define 2000.03.19 ***/
  111. static int dosnmp_trace(int argc,char *argv[],struct user *u);
  112. static void CreateSnmpComm (SNMP_COMMUNITY *snmp_para_comm);
  113. static int dosnmp_engineID(int argc,char *argv[],struct user *u);
  115. static BOOL display_snmp_user();
  116. static int display_snmp_group();
  117. static int resolve_commmunity(char* name,int *index);
  118. static int dosnmp_srcipaddr(int argc, char *argv[],struct user* u);
  119. static char *snmp_storage_trans[] = {"nonexistent", "other", "volatile", "nonvolatile",
  120. "permanent", "readonly"};
  121. static char *snmp_status_trans[] = {"nonexistent", "active", "not-in-service",
  122. "not-ready", "create-and-go", "create-and-wait", "destroy"};
  124. struct cmds Snmpcmds[] = {
  125. { "community", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  126. dosnmp_community,NULL,NULL, 0, 0, 
  127. "community        --  Enable SNMP; set community string and access privs", 
  128. "community        --  启用 SNMP; 设置 community 字符串", 
  129. NULLCHAR ,NULLCHAR },
  130. { "contact", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  131. dosnmp_contact,NULL,NULL, 0, cmdArgc(2,1,0), 
  132. "contact          --  Text for mib object sysContact", 
  133. "contact          --  设置 mib 对象 sysContact", 
  134. "LINE             --  identification of the contact person for this managed node",
  135. "LINE             --  该管理节点联系人" },
  136. #ifdef INCLUDE_SNMPV3
  137. { "engineID", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  138. dosnmp_engineID,NULL,NULL, 0, 0, 
  139. "engineID         --  Configure a local or remote SNMPv3 engineID",
  140. "engineID         --  配置本地或远端的SNMP引擎ID", 
  141.   NULLCHAR,NULLCHAR},
  142. { "group", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  143. dosnmp_group,NULL,NULL, 0, 0, 
  144. "group            --  Define a User Security Model group",
  145. "group            --  定义基于用户的安全模型的组", 
  146.   NULLCHAR,NULLCHAR},
  147. #endif
  148. { "host", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  149. dosnmp_host,NULL,NULL, 0, 0, 
  150. "host             --  Specify hosts to receive SNMP TRAPs", 
  151. "host             --  指定接收 SNMP TRAPs 的目的主机", 
  152. NULLCHAR,NULLCHAR},
  153. /*** 2000.03.16  ***
  154. "?Hostname or A.B.C.D  --  IP address of SNMP TRAP host" ,
  155. "Hostname or A.B.C.D  --  IP address of SNMP TRAP host" },
  156. ******/
  157. { "location", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  158. dosnmp_location,NULL,NULL, 0, cmdArgc(2,1,0), 
  159. "location         --  Text for mib object sysLocation", 
  160. "location         --  设置 mib 对象 sysLocation", 
  161. NULLCHAR,NULLCHAR },
  162.            
  163. { "packetsize", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  164. dosnmp_packetsize,NULL,NULL, 0, cmdArgc(0,1,0), 
  165. "packetsize       --  Largest SNMP packet size", 
  166. "packetsize       --  设置最大的 SNMP 数据包尺寸", 
  167. "<484-17940>    --  Packet size",
  168. "<484-17940>    --  数据包尺寸" },
  169.          
  170. { "queue-length", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  171. dosnmp_queuelen,NULL,NULL, 0, cmdArgc(0,1,0), 
  172. "queue-length     --  Message queue length for each TRAP host", 
  173. "queue-length     --  设置针对每个 TRAP 主机的消息队列长度", 
  174. "<1-1000>    --  Queue length (default 10)",
  175. "<1-1000>    --  队列长度 (缺省 10)" },
  177. { "trap-source", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  178. dosnmp_trap_source,NULL,NULL, cmdArgc(2,2,0), cmdArgc(0,0,0), 
  179. "trap-source      --  Assign an interface for the source address of all traps", 
  180. "trap-source      --  指定一个 interface 用于所有 trap 的源地址", 
  181. NULLCHAR,NULLCHAR},
  182.          
  183. { "trap-timeout", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  184. dosnmp_trap_timeout,NULL,NULL, 0, cmdArgc(0,1,0), 
  185. "trap-timeout     --  Set timeout for TRAP message retransmissions", 
  186. "trap-timeout     --  设置重发 TRAP 消息的超时值", 
  187. "<1-1000>    --  Timeout (default 30 seconds)",
  188. "<1-1000>    --  超时值 (缺省 30 秒)"},
  189. #ifdef INCLUDE_SNMPV3
  190. { "user", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  191. dosnmp_user,NULL,NULL, 0, 0, 
  192. "user             --  Define a user who can access the SNMP engine",
  193. "user             --  定义能够访问本SNMP引擎的用户", 
  194.   NULLCHAR,NULLCHAR},
  195. #endif
  196. { "view", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  197. dosnmp_view,NULL,NULL, cmdArgc(0,2,0), 0, 
  198. "view             --  Define an SNMP MIB view", 
  199. "view             --  定义 SNMP MIB view", 
  200.   NULLCHAR,NULLCHAR},
  201.  
  202.    { "source-addr", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  203. dosnmp_srcipaddr,NULL,NULL, 2, 0, 
  204. "source-addr                 -- Set source IP Address", 
  205. "source-addr                  -- 设置源IP地址", 
  206.   NULLCHAR,NULLCHAR},
  207. { NULLCHAR }
  208. };
  213. /*************************************************/
  217. /** snmp top command */
  218. int do_snmp(int argc, char *argv[], struct user *u)
  219. {
  220. return subcmd(Snmpcmds,NULL, argc, argv, u);
  221. }
  223. /* snmp command
  224. * snmp community ****
  225. */
  226. #if 0
  227. static int dosnmp_community_name(int argc, char *argv[], struct user *u);
  228. #endif
  230. static int dosnmp_community_acl(int argc,char *argv[],struct user *u);
  231. static int dosnmp_community_ro(int argc,char *argv[],struct user *u);
  232. static int dosnmp_community_rw(int argc,char *argv[],struct user *u);
  233. static int dosnmp_community_view(int argc,char *argv[],struct user *u);
  234. static int display_snmp_community(void);
  235. static void init_a_community(SNMP_COMMUNITY *community);
  237. /** snmp community command structure */
  238. struct cmds snmp_community_privilege_cmds[] = {
  240. { "", MATCH_STR, 0, 0x1, dosnmp_community_acl,NULL,NULL, 0, 0, /*v0.0.6 max 0->1*/
  241. "WORD    --  Std IP accesslist allowing access with this community string", 
  242. "WORD    --  使用该团体允许访问的标准 IP 访问列表", 
  243. NULLCHAR,NULLCHAR},
  244. { "ro", MATCH_AMB, 0, 0x2, dosnmp_community_ro,NULL,NULL, 0, 0, 
  245. "ro      --  Read-only access with this community string", 
  246. "ro      --  使用该团体可访问只读 MIB", 
  247. NULLCHAR,NULLCHAR},
  248. { "rw", MATCH_AMB, 0, 0x2, dosnmp_community_rw,NULL,NULL, 0, 0, 
  249. "rw      --  Read-write access with this community string", 
  250. "rw      --  使用该团体可访问读写 MIB", 
  251. NULLCHAR,NULLCHAR},
  252. { "view", MATCH_AMB, 0, 0x8, dosnmp_community_view,NULL,NULL, 0, 0, 
  253. "view    --  Restrict this community to a named MIB view", 
  254. "view    --  限定该团体可访问的 MIB 视图", 
  255. "WORD    --  MIB view to which this community has access",
  256. "WORD    --  MIB 视图",},
  257. { (char *)-1, MATCH_END, cmdPref(PF_CMDNO, 0, 0), 0x10, NULL, 
  258. NULL,NULL,0, cmdArgc(0,0,0), 
  259. "<cr>",
  260. "结束",
  261. NULLCHAR ,NULLCHAR},
  262. { NULLCHAR }
  264. };
  267. /* function: snmp community */
  268. static int dosnmp_community(argc,argv,u)
  269. int argc;
  270. char *argv[];
  271. struct user *u;
  272. {
  273. int i, rc;
  274. SNMP_COMMUNITY community;
  275. char *name;
  277. if(IsNoPref(u) && argc<2){
  278. vacm_DestroyCommunityAll();
  279. return 0;
  280. }
  282. u->struct_p[COMMUNITY]=(unsigned long )&community;
  284. switch(getstrrc(&name,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  285. case ARG_NOERR: 
  286.     break;
  287.     case ARG_QUEST:
  288.     case ARG_QUERY:
  289.         eng_chi(u,  "  WORD    --  SNMP community string",
  290.                         "  WORD    --  SNMP 团体名字符串");
  291.         return 1;
  292.     case ARG_PARAM:
  293.     case ARG_QPART:
  294. case ARG_GENER:
  295.     default:
  296.      return -1;
  297. }
  299. if (resolve_commmunity(name,&i)<0)
  300. {
  301. vty_output("SNMP(@err):exceed the max num of community list(%d)n",SNMP_MAX_COMMUNITY_NUM);
  302. return 0;
  303. }else{
  304. u->struct_p[COMMUNITY_INDEX] = i;
  305. }
  308. memset(&community,0,sizeof(SNMP_COMMUNITY));
  309. strncpy(community.name,name,SNMP_MAX_COMMUNITY_LEN-1);
  311. if(argc==1){
  312. if(IsNoPref(u)){/*no snmp community argv[0]*/
  313. if (vacm_FindSecEntryByCommName (name) != NULL)
  314. {
  315. vacm_DestroyCommunity (name);
  316. }
  317. else
  318. {
  319. vty_output("Cann't find community %sn",name);
  320. return -1;
  321. }
  322. }else{
  323. CreateSnmpComm (&community); /*Modified by sxf oct.30.2k*/
  324. /*ASSIGN(snmp_para.community[i],community);*/
  325. }
  326. return 0;
  327. }
  330. u->cmd_mskbits =0x1f;
  332. if ((rc = subcmd(snmp_community_privilege_cmds,&u->cmd_mskbits, argc, argv, u))==0){
  333. CreateSnmpComm (&community); 
  334. return 0;
  335. }
  336. else
  337.     return rc;
  339. }
  341. void display_a_community(struct vacm_securityEntry *community)
  342. {
  344. if(community->community[0]){
  345. vty_printf("snmp-server community %s ",community->community);
  346. if (community->viewname[0]){
  347. vty_printf("view %s ",community->viewname);
  348. }
  349. vty_printf("%s ",(community->privilege==READONLY)?"RO":"RW");/*0.0.8*/
  350. if(community->access_list[0]){
  351. vty_printf("%s",community->access_list);
  352. }
  353. vty_printf("n");
  354. }
  355. }
  357. static int display_snmp_community(void)
  358. {
  359. if (vacm_walkThrSecEntry (display_a_community))
  360. {
  361. return FALSE;
  362. }
  363. else
  364. {
  365. return TRUE;
  366. }
  367. }
  370. void init_community(void)
  371. {
  372. int i;
  373. for(i=0;i<SNMP_MAX_COMMUNITY_NUM;i++){
  374. init_a_community(&snmp_para.community[i]);
  375. }/*for*/
  376. return;
  377. }
  379. static void init_a_community(SNMP_COMMUNITY *community)
  380. {
  381. memset(community,0,sizeof(SNMP_COMMUNITY));
  382. return;
  383. }
  385. /***/
  386. static int resolve_commmunity(char* name,int *index)
  387. {
  388. int i;
  390. for(i=0;i<SNMP_MAX_COMMUNITY_NUM;i++){
  391. if(!strcmp(snmp_para.community[i].name,name)) {
  392. *index=i;
  393. return 1;
  394. }
  395. }
  397. if(i>=SNMP_MAX_COMMUNITY_NUM){
  398. for(i=0;i<SNMP_MAX_COMMUNITY_NUM;i++)
  399. if(snmp_para.community[i].name[0]==0){
  400. *index=i;
  401. return 0;
  402. }
  403. }
  404. *index=-1;
  405. return -1;
  406. }
  409. static int dosnmp_community_ro(int argc,char *argv[],struct user *u)
  410. {
  411. SNMP_COMMUNITY *community =(SNMP_COMMUNITY *)u->struct_p[COMMUNITY];
  413. community->privilege = READONLY;
  415. if (argc>1){
  416. return subcmd(snmp_community_privilege_cmds,&u->cmd_mskbits, argc, argv, u);
  417. }
  419. return 0;
  420. }
  422. static int dosnmp_community_rw(int argc,char *argv[],struct user *u)
  423. {
  424. SNMP_COMMUNITY *community =(SNMP_COMMUNITY *)u->struct_p[COMMUNITY];
  426. community->privilege = READWRITE;
  428. if (argc>1){
  429. return subcmd(snmp_community_privilege_cmds,&u->cmd_mskbits, argc, argv, u);
  430. }
  431. return 0;
  432. }
  434. static int dosnmp_community_acl(int argc,char *argv[],struct user *u)
  435. {
  436. SNMP_COMMUNITY *community =(SNMP_COMMUNITY *)u->struct_p[COMMUNITY];
  437. char *acl;
  439.     /*由于命令行参数已经被用于匹配命令字,这里需要回退*/
  440.     argc++,argv--;
  441. switch(getstrrc(&acl,  argc--, argv++, 0, NAME_MAXLEN, u)){
  442. case ARG_NOERR: 
  443.     break;
  444.     case ARG_QUEST:
  445.     case ARG_QUERY:
  446.         vty_output("WORDn");
  447.         eng_chi(u, "  WORD  -- Std IP accesslist allowing access with this community string",
  448.                    "  WORD  -- 使用该团体允许访问的标准 IP 访问列表");
  449.         return 1;
  450.     case ARG_PARAM:
  451.     case ARG_QPART:
  452. case ARG_GENER:
  453.     default:
  454.      return -1;
  455. }
  457. strncpy(community->access_list,acl,NAME_MAXLEN-1);
  458. community->access_list[NAME_MAXLEN-1] = '';
  460. if (argc>1){
  461. return subcmd(snmp_community_privilege_cmds,&u->cmd_mskbits, argc, argv, u);
  462. }
  463. return 0;
  465. }
  468. static int dosnmp_community_view(int argc,char *argv[],struct user *u)
  469. {
  470. SNMP_COMMUNITY *community =(SNMP_COMMUNITY *)u->struct_p[COMMUNITY];
  471.     char *p;
  473. if (argc==1){
  474. if(IsChinese(u)){
  475. vty_output("命令不完整n");
  476. }else{
  477. vty_output("Incomplete commandn");
  478. }
  479. return -1;
  480. }
  481. switch(getstrrc(&p,  argc, argv, 0, SNMP_MAX_VIEW_LEN, u)){
  482. case ARG_NOERR: 
  483.          strncpy(community->viewname,p,MAX_NAME_LEN-1);
  484.     break;
  485.     case ARG_QUERY:
  486.     case ARG_QUEST:
  487.         vty_output("WORDn");
  488.         return 1;
  489.     case ARG_PARAM:
  490.     case ARG_QPART:
  491. case ARG_GENER:
  492.     default:
  493.      return -1;
  494. }
  495. --argc;
  496. ++argv;
  498. #if 0 /*  2000.06.19   */
  499. strncpy(community->viewname,argv[1],MAX_NAME_LEN-1);
  501. u->cmd_mskbits = 0x17;/*for <1-99 and <cr>>*/
  502. --argc;
  503. ++argv;
  504. #endif /* #if 0 */
  505. if (argc>1){
  506. return subcmd(snmp_community_privilege_cmds,&u->cmd_mskbits, argc, argv, u);
  507. }
  508. return 0;
  509. }
  511. #if 0
  512. struct cmds snmp_contact_cmds[] = {
  513. { "LINE", MATCH_STR, 0, 0, dosnmp_contact_name, NULL,NULL,0, cmdArgc(0,0,0), 
  514. "LINE       --  identification of the contact person for this managed node",
  515. "LINE       --  该管理节点的联系人标识符",
  516. NULLCHAR ,NULLCHAR},
  518. {NULLCHAR}
  519. };
  520. #endif
  521. /**
  522. **snmp command
  523. **snmp contact ***
  524. **/
  525. static int dosnmp_contact(argc,argv,u)
  526. int argc;
  527. char *argv[];
  528. struct user *u;
  529. {
  530.     char *p;
  531. if(argc==1){
  532. if(IsNoPref(u)){/*no snmp host argv[0]*/
  533. memset(snmp_para.syscontact,0,SNMP_MAX_SYSCON_LEN);
  534. }else{
  535. display_snmp_contact();
  536. }
  537. return 0;
  538. }
  540. switch(getstrrc(&p,  argc, argv, 0, SNMP_MAX_SYSCON_LEN, u)){
  541. case ARG_NOERR: 
  542.          strncpy(snmp_para.syscontact,argv[1],SNMP_MAX_SYSCON_LEN-1);
  543.     break;
  544.     case ARG_QUERY:
  545.     case ARG_QUEST:
  546.         eng_chi(u, "  WORDttt--  contact informationn",
  547.                    "  WORDttt--  联系信息n");
  548.             return 1;
  549.     case ARG_PARAM:
  550.     case ARG_QPART:
  551. case ARG_GENER:
  552.     default:
  553.      return -1;
  554. }
  555.     return 0;
  556. }
  557. #if 0
  558. static int dosnmp_contact_name(int argc,char *argv[],struct user *u)
  559. {
  560. memset(snmp_para.syscontact,0,SNMP_MAX_SYSCON_LEN);
  561. strncpy(snmp_para.syscontact,argv[0],SNMP_MAX_SYSCON_LEN-1);
  562. return 0;
  563. }
  564. #endif
  565. void display_snmp_contact(void)
  566. {
  567. if(snmp_para.syscontact[0]){
  568. vty_output("snmp contact %sn",
  569. snmp_para.syscontact);
  570. }else{
  571. vty_output("Nonen");
  572. }
  574. }
  577. /*snmp command
  578. *snmp host ***
  579. */
  580. static int  display_snmp_host(void);
  581. static void display_a_host(int itemp);
  582. static int dosnmp_host_delete(SNMP_TRAPSINK *snmphost);
  583. static int dosnmp_host_add(int argc,char *argv[],struct user *u);
  584. static int dosnmp_host_community(int argc,char *argv[],struct user *u);
  585. static int resolve_trapsink(SNMP_TRAPSINK *snmphost, int *index);
  586. static void dosnmp_host_addhost(SNMP_TRAPSINK *snmphost);
  587. static int dosnmp_host_community_snmp(int argc,char *argv[],struct user *u);
  588. static int dosnmp_host_community_auth(int argc,char *argv[],struct user *u);
  589. static int dosnmp_host_community_config(int argc,char *argv[],struct user *u);
  590. static int dosnmp_host_inform(int argc,char *argv[],struct user *u);
  591. static int dosnmp_host_trap(int argc,char *argv[],struct user *u);
  592. static int dosnmp_host_version(int argc,char *argv[],struct user *u);
  593. /* by yangyuhua 2006-4-7 */
  594. static int dosnmp_host_vrf(int argc,char *argv[],struct user *u);
  596. static int dosnmp_host_version_choice(int argc,char *argv[],struct user *u);
  597. static int dosnmp_host_version3_authpara(int argc,char *argv[],struct user *u);
  598. static int do_show_snmp_user(int argc,char *argv[],struct user *u);
  599. static int do_show_snmp_group(int argc,char *argv[],struct user *u);
  600. static int do_show_snmp_engineID(int argc,char *argv[],struct user *u);
  602. struct cmds snmp_host_cmds[] = {
  603. { (char *)-1, MATCH_STR,  cmdPref(PF_CMDNO, 0, 0), 0, 
  604. dosnmp_host_add, NULL,NULL,cmdArgc(0,2,2), 0, 
  605. "Hostname or A.B.C.D  --  IP address of SNMP TRAP host",
  606. "Hostname or A.B.C.D  --  接收SNMP TRAP主机的 IP 地址",
  607. NULLCHAR ,NULLCHAR},
  608. /*
  609. { (char *)-1, MATCH_END, 0, 0x10, NULL, NULL,NULL,0, 0, 
  610. "<cr>                 --  Display Current host configure",
  611. "结束                 --  显示当前 host 配置",
  612. NULLCHAR ,NULLCHAR},
  613. { (char *)-1, MATCH_END,  0, 0x20, NULL,NULL,NULL,0, 0, 
  614. "<cr>",
  615. "结束",
  616. NULLCHAR ,NULLCHAR},
  617. */
  619. {NULLCHAR}
  620. };
  622. struct cmds snmp_host_hostname_cmds[] = {
  623. { "WORD", MATCH_STR, cmdPref(PF_CMDNO, 0, 0), 0x1, dosnmp_host_community, NULL,NULL,0, 0, 
  624. #ifdef INCLUDE_SNMPV3
  625. "WORD    --  SNMPv1/v2c community string or SNMPv3 user name",
  626. "WORD    --  SNMPv1/v2c 团体字符串或SNMPv3用户名",
  627. #else
  628. "WORD    --  SNMP community string",
  629. "WORD    --  SNMP 团体字符串",
  630. #endif
  631. NULLCHAR ,NULLCHAR},
  632. { "informs", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x2, dosnmp_host_inform, NULL,NULL,0, 0, 
  633. "informs           --  Send Inform messages to this host",
  634. "informs           --  向该主机发送inform",
  635. NULLCHAR ,NULLCHAR},
  636. { "traps", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x2, dosnmp_host_trap, NULL,NULL,0, 0, 
  637. "traps             --  Send Trap messages to this host",
  638. "traps             --  向该主机发送trap",
  639. NULLCHAR ,NULLCHAR},
  640. { "version", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x4, dosnmp_host_version, NULL,NULL,0, 0, 
  641. "version           --  SNMP version to use for notification messages",
  642. "version           --  向主机发送通知类报文的版本号",
  643. NULLCHAR ,NULLCHAR},
  644. /* by yangyuhua 2006-4-7 */
  645. { "vrf", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x8, dosnmp_host_vrf, NULL,NULL,0, 0, 
  646. "vrf     --  Bind vrf name ",
  647. "vrf     --  绑定vrf ",
  648. NULLCHAR ,NULLCHAR},
  650. {NULLCHAR}
  651. };
  653. #define SNMP_HOST_V1 0x01
  654. #define SNMP_HOST_V2c 0x02
  655. #define SNMP_HOST_V3 0x04
  656. struct cmds snmp_host_hostname_version_cmds[] = {
  657. { "v1", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMP_HOST_V1, dosnmp_host_version_choice, NULL,NULL,0, 0, 
  658. "v1                --  Use SNMPv1",
  659. "v1                --  使用版本1",
  660. NULLCHAR ,NULLCHAR},
  661. { "v2c", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMP_HOST_V2c, dosnmp_host_version_choice, NULL,NULL,0, 0, 
  662. "v2c               --  Use SNMPv2c",
  663. "v2c               --  使用版本2c",
  664. NULLCHAR ,NULLCHAR},
  665. #ifdef INCLUDE_SNMPV3
  666. { "v3", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMP_HOST_V3, dosnmp_host_version_choice, NULL,NULL,0, 0, 
  667. "v3                --  Use SNMPv3",
  668. "v3                --  使用版本3",
  669. NULLCHAR ,NULLCHAR},
  670. #endif
  671. {NULLCHAR}
  672. };
  674. #ifdef INCLUDE_SNMPV3
  675. #define SNMPV3_HOST_V3_AUTH 0x01
  676. #define SNMPV3_HOST_V3_NOAUTH 0x02
  678. struct cmds snmp_host_hostname_version3_auth_cmds[] = {
  679. { "auth", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_HOST_V3_AUTH, dosnmp_host_version3_authpara, NULL,NULL,0, 0, 
  680. "auth              --  Use the SNMPv3 authNoPriv Security Level",
  681. "auth              --  使用版本3认证不加密安全级别",
  682. NULLCHAR ,NULLCHAR},
  683. { "noauth", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_HOST_V3_NOAUTH, dosnmp_host_version3_authpara, NULL,NULL,0, 0, 
  684. "noauth            --  Use the SNMPv3 noAuthNoPriv Security Level",
  685. "noauth            --  使用版本3不认证不加密安全级别",
  686. NULLCHAR ,NULLCHAR},
  687. {NULLCHAR}
  688. };
  691. #endif
  693. struct cmds snmp_host_community_cmds[] = {
  694. { "authentication", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x1, dosnmp_host_community_auth,NULL,NULL,0, cmdArgc(0,0,0), 
  695. "authentication    --  Allow authentication failure traps",
  696. "authentication    --  允许发送认证失败traps",
  697. NULLCHAR ,NULLCHAR},
  699. { "configure", MATCH_AMB, 0, 0x2, dosnmp_host_community_config, NULL,NULL,0, 0, 
  700. "configure         --  Allow SNMP-configure traps",
  701. "configure         --  允许发送 SNMP 配置 traps",
  702. NULLCHAR ,NULLCHAR},
  704. { "snmp", MATCH_AMB, 0, 0x4, dosnmp_host_community_snmp, NULL,NULL,0, 0, 
  705. "snmp              --  Allow SNMP-type traps",
  706. "snmp              --  允许发送 SNMP traps",
  707. NULLCHAR ,NULLCHAR},
  708. { (char *)-1, MATCH_END, cmdPref(PF_CMDNO, 0, 0), 0x20, NULL,
  709. NULL,NULL,0, 0, 
  710. /* "<cr>              --  Allow all traps",
  711. "结束              --  允许发送所有traps", *//* v0.0.3*/
  712. "<cr>",
  713. "结束",
  715. NULLCHAR ,NULLCHAR},
  717. {NULLCHAR}
  718. };
  720. static int dosnmp_host(argc,argv,u)
  721. int argc;
  722. char *argv[];
  723. struct user *u;
  724. {
  725. return subcmd(snmp_host_cmds,&u->cmd_mskbits, argc, argv, u);
  726. }
  727. /*** sun define 2000.03.12 ***/
  728. static int dosnmp_host_add(int argc,char *argv[],struct user *u)
  729. {
  730. SNMP_TRAPSINK snmphost;
  731. int res;
  732. memset(&snmphost,0,sizeof(SNMP_TRAPSINK));
  733. snmphost.pdutype = SNMP_MSG_TRAP;
  734. snmphost.trapflags = 0xFFFF;
  735. u->struct_p[SNMP_HOST] = (unsigned long)&snmphost;
  736. strncpy (snmphost.hostname, *(argv), SNMP_MAX_HOSTNAME_LEN-1);
  737. u->cmd_mskbits = 0x1F;
  738. #ifdef SWITCH
  739. res = 0;
  740. #else
  741. res=ip_vrf_enable_status();
  742. #endif
  743.        if(!res){/*support vrf*/
  744.     u->cmd_mskbits &= ~0x8;
  745.         }
  746. return subcmd(snmp_host_hostname_cmds,&u->cmd_mskbits, argc, argv, u);
  747. }
  749. static int display_snmp_host(void)
  750. {
  751. int i;
  752. int    emptyconfiguration = TRUE;
  753. for(i=0;i<SNMP_MAX_TRAPSINK;i++){
  754. if(snmp_para.trapsink[i].ipaddr!=0)
  755. break;
  756. }/*for*/
  758. if (i>=SNMP_MAX_TRAPSINK){
  759. #if 0 /*  2000.04.03   */
  760. vty_printf("Nonen");
  761. #endif /* #if 0 */
  762. return emptyconfiguration;
  763. }else{
  764. for(i=0;i<SNMP_MAX_TRAPSINK;i++){
  765. display_a_host(i);
  766. }/*for*/
  767. emptyconfiguration = FALSE;
  768. }
  770. return emptyconfiguration;
  772. }
  773. static void display_a_host(int itemp)
  774. {
  775. SNMP_TRAPSINK * trapsink;
  776. if ((itemp >= 0 ) && (itemp < SNMP_MAX_TRAPSINK))
  777. trapsink = (SNMP_TRAPSINK * )(&(snmp_para.trapsink[itemp]));
  778. else return;
  780. if(trapsink->ipaddr){
  781. vty_printf("snmp-server host %s ",snmp_ntoa(trapsink->ipaddr));
  782. /*by yangyuhua 2006-4-7*/
  783. if(trapsink->vrfname[0])
  784. vty_printf("vrf %s ",trapsink->vrfname);
  786. if (trapsink->pdutype == SNMP_MSG_INFORM)
  787.     vty_printf("informs ");
  788.     switch (trapsink->version) {
  789.     case SNMP_VERSION_2c:
  790.         vty_printf("version v2c ");
  791.         break;
  792.     case SNMP_VERSION_3:
  793.         vty_printf("version v3 ");
  794.         if (trapsink->authtype == SNMP_SEC_LEVEL_NOAUTH)
  795.             vty_printf("noauth ");
  796.             else
  797.                 vty_printf("auth ");
  798.         break;
  799.     }
  800. if(trapsink->community[0])
  801. vty_printf("%s ",trapsink->community);
  802. if(trapsink->trapflags){
  803. if(trapsink->trapflags!=0xffff)
  804. {
  805. if(trapsink->trapflags&SNMP_AUTH_TRAP)
  806. vty_printf("authentication ");
  807. if(trapsink->trapflags&SNMP_CONFIG_TRAP)
  808. vty_printf("configure ");
  809. if(trapsink->trapflags&SNMP_SNMPTYPE_TRAP)
  810. vty_printf("snmp");
  811. }
  812. }
  813. vty_printf("n");
  814. }
  816. }
  818. static int dosnmp_host_delete(SNMP_TRAPSINK *snmphost)
  819. {
  820. int i,ret;
  821. if(snmphost->ipaddr==0){
  822. vty_output("Invalid IP address or unknow hostnamen");
  823. /*** 2000.03.15  ***
  824. vty_output("SNMP:非法IP地址或者未配置的主机名 %sn",argv[1]);
  825. ******/
  826. return 0;
  827. }
  828. ret = resolve_trapsink(snmphost, &i);
  829. if(ret==1){
  830. memset(&snmp_para.trapsink[i],0,sizeof(SNMP_TRAPSINK));
  831. }else{
  832. vty_output("Cannot find host %sn",snmp_ntoa(snmphost->ipaddr));
  833. }
  834. return 0;
  835. }
  837. static int dosnmp_host_community(int argc,char *argv[],struct user *u)
  838. {
  839. SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  840. struct hostent *hp;
  841. int rc;
  843.     strncpy(snmphost->community,argv[0],SNMP_MAX_COMMUNITY_LEN-1);
  844.     if(IsNoPref(u)){/*no snmp host <hostnameipaddree>*/
  845. u->cmd_mskbits = 0x2F;
  846. rc = cmdend(--argc, ++argv, u);
  847. if (rc)
  848.     return rc;
  850. if ((snmphost->ipaddr = inet_addr (snmphost->hostname)) 
  851. == INADDR_NONE) {
  852. vty_output ("Translating "%s"... n", snmphost->hostname); 
  853. hp = gethostbyname(snmphost->hostname);
  854. if (hp == NULL)
  855. {
  856. vty_output (" Unknown hostname "%s"n", snmphost->hostname);
  857. return -1;
  858. }
  859. else
  860. {
  861. vty_output ("Successn");
  862. memcpy(&(snmphost->ipaddr), hp->h_addr, 4);
  863. }
  864. }
  865. dosnmp_host_delete(snmphost);
  866. return 0;
  867. }
  868. else
  869. {
  870. if(argc<2){
  871. /* strncpy(snmphost->community,argv[0],SNMP_MAX_COMMUNITY_LEN-1);*//*v0.0.3*/
  872. snmphost->trapflags = 0xffff;/*all*/
  873. dosnmp_host_addhost(snmphost);
  874. return 0;
  875. }
  876. u->cmd_mskbits = 0xFF;
  877. snmphost->trapflags = 0;/*For Bug  SWBUG00006106*/
  878.     if ((rc = subcmd(snmp_host_community_cmds,&u->cmd_mskbits, argc, argv, u))==0){
  879.   dosnmp_host_addhost(snmphost);
  880.             return 0;
  881.     }
  882.     else
  883.         return rc;
  884.  }
  885.  return 0;
  887. }
  889. static int dosnmp_host_inform(int argc,char *argv[],struct user *u)
  890. {
  891.     SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  892.     snmphost->pdutype = SNMP_MSG_INFORM;
  893. /*yangyhuhua(a) 2006-4-14*/
  894.     snmphost->version = SNMP_VERSION_2c;
  895.     u->cmd_mskbits &= ~0x02;
  896.     return subcmd(snmp_host_hostname_cmds, &u->cmd_mskbits, argc, argv, u);
  897. }
  899. static int dosnmp_host_trap(int argc,char *argv[],struct user *u)
  900. {
  901.     SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  902.     snmphost->pdutype = SNMP_MSG_TRAP;
  903.     u->cmd_mskbits &= ~0x02;
  904.     return subcmd(snmp_host_hostname_cmds, &u->cmd_mskbits, argc, argv, u);
  905. }
  907. static int dosnmp_host_version(int argc,char *argv[],struct user *u)
  908. {
  909. SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  911. u->cmd_mskbits = -1;
  912. /*yangyuhua(a) 2006-4-14*/
  913.     if ((snmphost->version > SNMP_VERSION_1) && (snmphost->version <= SNMP_VERSION_3))
  914. u->cmd_mskbits &= ~(SNMP_HOST_V1);
  916.     return subcmd(snmp_host_hostname_version_cmds, &u->cmd_mskbits, argc, argv, u);
  917. }
  919. static int dosnmp_host_version_choice(int argc,char *argv[],struct user *u)
  920. {
  921.     SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  922. /*yangyuhua(m) 2006-4-14*/
  923.     if (snmphost->pdutype == SNMP_MSG_INFORM)
  924.      {
  925.     if ((u->cmd_mskbits & SNMP_HOST_V2c) == 0) {
  926.         snmphost->version = SNMP_VERSION_2c;
  927.     } else if ((u->cmd_mskbits & SNMP_HOST_V3) == 0) {
  928.         snmphost->version = SNMP_VERSION_3;
  929.     } else
  930.         assert(0);
  931.      } else {
  932.     if ((u->cmd_mskbits & SNMP_HOST_V1) == 0) {
  933.         snmphost->version = SNMP_VERSION_1;
  934.     } else   if ((u->cmd_mskbits & SNMP_HOST_V2c) == 0) {
  935.         snmphost->version = SNMP_VERSION_2c;
  936.     } else if ((u->cmd_mskbits & SNMP_HOST_V3) == 0) {
  937.         snmphost->version = SNMP_VERSION_3;
  938.     } else
  939.         assert(0);
  940.      }
  941.     if (snmphost->version != SNMP_VERSION_1 && snmphost->pdutype == SNMP_MSG_TRAP)
  942.         snmphost->pdutype = SNMP_MSG_TRAP2;
  943. #ifdef INCLUDE_SNMPV3
  944.     if (snmphost->version == SNMP_VERSION_3) {
  945.         u->cmd_mskbits = -1;
  946.         return subcmd(snmp_host_hostname_version3_auth_cmds, &u->cmd_mskbits, argc, argv, u);
  947.     }
  948.     else
  949. #endif
  950.     {
  951.         u->cmd_mskbits = 1;
  952.         return subcmd(snmp_host_hostname_cmds, &u->cmd_mskbits, argc, argv, u);
  953.     }
  954. }
  956. #ifdef INCLUDE_SNMPV3
  957. static int dosnmp_host_version3_authpara(int argc,char *argv[],struct user *u)
  958. {
  959.     SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  961.     if ((u->cmd_mskbits & SNMPV3_HOST_V3_AUTH) == 0) {
  962.         snmphost->authtype = SNMP_SEC_LEVEL_AUTHNOPRIV;
  963.     } else if ((u->cmd_mskbits & SNMPV3_HOST_V3_NOAUTH) == 0) {
  964.         snmphost->authtype = SNMP_SEC_LEVEL_NOAUTH;
  965.     }
  967.     u->cmd_mskbits = 1;
  968.     return subcmd(snmp_host_hostname_cmds, &u->cmd_mskbits, argc, argv, u);
  969. }
  970. #endif
  972. /* by yangyuhua 2006-4-7 */
  973. static int  dosnmp_host_vrf(int argc, char *argv[], struct user *u)
  974. {
  975.    SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  976.    char *p;
  977.    uint32 rc;
  978.   
  979. if(argc ==1){
  981. cmderror(ERR_INCOM, argv[0], u);
  982. return -1;
  983. }
  984. else {
  985. switch(getstrrc(&p,  argc, argv, 0, SNMP_VRF_NAME_LEN, u)){
  986. case ARG_NOERR: 
  987.     /*snmphost->vrfid= get_vrf_id_byname(p);*/
  988. strcpy(snmphost->vrfname,p);
  989.     break;
  990.     case ARG_QUERY:
  991.     case ARG_QUEST:
  992.        eng_chi(u, "  WORD    --  VPN Routing/Forwarding instance name(up to 16 chars)", "  WORD      -- VRF名字(  最多16个字符)");
  993.         return 1;
  994.     case ARG_PARAM:
  995.     case ARG_QPART:
  996. case ARG_GENER:
  997.     default:
  998.      return -1;
  999. }
  1000. }
  1001. if (argc==2) return 0;
  1002. else {
  1003. u->cmd_mskbits &= ~0x08;
  1004. return subcmd(snmp_host_hostname_cmds,&u->cmd_mskbits, argc-1, argv+1, u);
  1005. }
  1006. }
  1009. static void dosnmp_host_addhost(SNMP_TRAPSINK *snmphost)
  1010. {
  1011. int ret,i;
  1012. struct hostent *hp;
  1014. if ((snmphost->ipaddr = inet_addr (snmphost->hostname)) 
  1015. == INADDR_NONE) {
  1016. vty_output ("Translating "%s"... n", snmphost->hostname); 
  1017. hp = gethostbyname(snmphost->hostname);
  1018. if (hp == NULL)
  1019. {
  1020. vty_output ("Unknown hostname "%s"n", snmphost->hostname);
  1021. return;
  1022. }
  1023. else
  1024. {
  1025. vty_output ("Successn");
  1026. memcpy(&(snmphost->ipaddr), hp->h_addr, 4);
  1027. }
  1028. }
  1030. ret=resolve_trapsink(snmphost, &i);
  1032. if (ret<0){
  1033. vty_output("SNMP:Too many trap hosts. The maximum number is(%d)n",SNMP_MAX_TRAPSINK);
  1034. return;
  1035. }else{
  1036.     switch (snmphost->version) {
  1037.     case SNMP_VERSION_1:
  1038.      if(createV1TrapSession((char*)snmp_ntoa(snmphost->ipaddr),(char*)snmphost->community,
  1039.      snmphost->trapflags, snmphost->vrfname)>0){
  1040.          ASSIGN(snmp_para.trapsink[i],*snmphost);
  1041.      }else{
  1042.      vty_output("SNMP:system too busy,can not create trap sessionn");
  1043.      }
  1044.      break;
  1045. case SNMP_VERSION_2c:
  1046.      if(createV2TrapSession(snmp_ntoa(snmphost->ipaddr),snmphost->community,
  1047.      snmphost->trapflags, snmphost->pdutype, snmphost->vrfname)>0){
  1048.          ASSIGN(snmp_para.trapsink[i],*snmphost);
  1049.      }else{
  1050.      vty_output("SNMP:system too busy,can not create trap sessionn");
  1051.      }
  1052.      break;
  1053. #ifdef  INCLUDE_SNMPV3
  1054. case SNMP_VERSION_3:
  1055.         ret = createV3TrapSession(snmp_ntoa(snmphost->ipaddr), snmphost->community,
  1056.                  snmphost->authtype, snmphost->pdutype, snmphost->trapflags,snmphost->vrfname);
  1057.         if (ret>0) {
  1058.             ASSIGN(snmp_para.trapsink[i],*snmphost);
  1059.             } else if (ret == 0) {
  1060.      vty_output("SNMP:system too busy,can not create trap sessionn");
  1061.             }
  1062.             break;
  1063. #endif /*INCLUDE_SNMPV3*/
  1064.         default:
  1065.             break;
  1066.     }
  1067. }
  1068. return ;
  1069. }
  1071. static int resolve_trapsink(SNMP_TRAPSINK *snmphost, int *index)
  1072. {
  1073. int i;
  1074. int return_val;
  1076. for(i=0;i<SNMP_MAX_TRAPSINK;i++){
  1077. if(snmphost->ipaddr==snmp_para.trapsink[i].ipaddr
  1078.          && strcmp (snmphost->community, snmp_para.trapsink[i].community)==0
  1079.          && snmp_para.trapsink[i].pdutype == snmphost->pdutype
  1080.          && strcmp (snmp_para.trapsink[i].vrfname, snmphost->vrfname)==0){
  1081. return_val = deleteTrapSession(snmp_ntoa(snmphost->ipaddr), snmphost->community, snmphost->version, snmphost->pdutype, snmphost->vrfname);
  1082. snmp_para.trapsink[i].community[0]=0;
  1083. /*** 2000.03.12  ***
  1085. hprintf(mngr_id,"SNMP:配置已修改n");
  1086. ******/
  1087. *index = i;
  1088. return return_val;
  1089. }
  1090. }
  1091. if(i>=SNMP_MAX_TRAPSINK){
  1092. for(i=0;i<SNMP_MAX_TRAPSINK;i++){
  1093. if(snmp_para.trapsink[i].community[0]==0){
  1094. *index = i;
  1095.      return_val = deleteTrapSession(snmp_ntoa(snmphost->ipaddr), snmphost->community, snmphost->version, snmphost->pdutype,snmphost->vrfname);
  1096. return return_val;
  1097. }
  1098. }
  1099. }
  1100. *index =-1;
  1101. return -1;
  1102. }
  1105. static int dosnmp_host_community_auth(int argc,char *argv[],struct user *u)
  1106. {
  1107. SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  1108. snmphost->trapflags |=SNMP_AUTH_TRAP;
  1109. if(argc>1){
  1110. return subcmd(snmp_host_community_cmds,&u->cmd_mskbits, argc, argv, u);
  1111. }
  1112. return 0;
  1113. }
  1115. static int dosnmp_host_community_config(int argc,char *argv[],struct user *u)
  1116. {
  1117. SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  1118. snmphost->trapflags |=SNMP_CONFIG_TRAP;
  1119. if(argc>1){
  1120. return subcmd(snmp_host_community_cmds,&u->cmd_mskbits, argc, argv, u);
  1121. }
  1123. return 0;
  1124. }
  1126. static int dosnmp_host_community_snmp(int argc,char *argv[],struct user *u)
  1127. {
  1128. SNMP_TRAPSINK *snmphost=(SNMP_TRAPSINK *)u->struct_p[SNMP_HOST];
  1129. snmphost->trapflags |=SNMP_SNMPTYPE_TRAP;
  1130. if(argc>1){
  1131. return subcmd(snmp_host_community_cmds,&u->cmd_mskbits, argc, argv, u);
  1132. }
  1134. return 0;
  1135. }
  1137. /*snmp command*/
  1138. struct cmds snmp_location_cmds[] = {
  1139. { "LINE", MATCH_STR, 0, 0, dosnmp_location_name, NULL,NULL,0, 0, 
  1140. "LINE       --  The physical location of this node",
  1141. "LINE       --  该节点的实际位置",
  1142. NULLCHAR ,NULLCHAR},
  1144. {NULLCHAR}
  1145. };
  1147. /* snmp location ***
  1148. */
  1149. static int dosnmp_location(argc,argv,u)
  1150. int argc;
  1151. char *argv[];
  1152. struct user *u;
  1153. {
  1155. if(argc==1){
  1156. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1157. memset(snmp_para.syslocation,0,SNMP_MAX_SYSLOC_LEN);
  1158. }else{
  1159. display_snmp_location();
  1160. }
  1161. return 0;
  1162. }else{
  1163.      return subcmd(snmp_location_cmds,NULL, argc, argv, u);
  1164. }
  1165. }
  1168. static int dosnmp_location_name(argc,argv,u)
  1169. int argc;
  1170. char *argv[];
  1171. struct user *u;
  1172. {
  1173. memset(snmp_para.syslocation,0,SNMP_MAX_SYSCON_LEN);
  1174.     strncpy(snmp_para.syslocation,argv[0],SNMP_MAX_SYSCON_LEN-1);
  1175. return 0;
  1176. }
  1179. void display_snmp_location(void)
  1180. {
  1181. if(snmp_para.syslocation[0]){
  1182. vty_output("snmp location %sn",snmp_para.syslocation);
  1183. }else{
  1184. vty_output("Nonen");
  1185. }
  1186. }
  1190. static int dosnmp_packetsize(argc,argv,u)
  1191. int argc;
  1192. char *argv[];
  1193. struct user *u;
  1194. {
  1195. int packetsize;
  1196.     long    rc;/*** sun define 2000.07.28 ***/
  1197. if(argc==1){
  1198. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1199. snmp_para.packetsize = SNMP_DEFAULT_PACKETSIZE;
  1200. }else{
  1201. vty_output("snmp packetsize %dn",
  1202. snmp_para.packetsize);
  1203. }
  1204. return 0;
  1205. }else{
  1206.  switch(getintrc(&packetsize, argc,argv,SNMP_MIN_PACKETSIZE,SNMP_MAX_PACKETSIZE,u)){
  1207.          case ARG_NOERR:
  1208.     break;
  1209. case ARG_QUEST :
  1210.          cmderror(ERR_NEXTP, NULL, u);
  1211.     default:
  1212.          return 1;
  1213. }/*switch*/
  1214.      if ((rc = cmdend(argc-2, argv+2, u)))/*** sun define 2000.07.28 ***/
  1215.      return rc;
  1217. snmp_para.packetsize = (unsigned short)packetsize;
  1218. }
  1219. return 0;
  1220. }
  1222. static int dosnmp_queuelen(argc,argv,u)
  1223. int argc;
  1224. char *argv[];
  1225. struct user *u;
  1226. {
  1227. int queuelen;
  1228.     long    rc;/*** sun define 2000.07.28 v0.0.6 ***/
  1229. if(argc==1){
  1230. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1231. snmp_para.queuelen = SNMP_DEFAULT_TRAP_QUEUELEN;
  1232. set_trapsinks(SET_SNMP_TRAP_QUEUELEN,SNMP_DEFAULT_TRAP_QUEUELEN);
  1233. }else{
  1234. vty_output("snmp queue-length %dn",
  1235. snmp_para.queuelen);
  1236. }
  1237. return 0;
  1238. }else{
  1239.  switch(getintrc(&queuelen, argc,argv,1,SNMP_MAX_TRAP_QUEUELEN,u)){
  1240.          case ARG_NOERR:
  1241.     break;
  1242. case ARG_QUEST :
  1243.          cmderror(ERR_NEXTP, NULL, u);
  1244.     default:
  1245.          return 1;
  1246. }/*switch*/
  1247.      if ((rc = cmdend(argc-2, argv+2, u)))/*** sun define 2000.07.28 ***/
  1248.      return rc;
  1250. snmp_para.queuelen = (unsigned short)queuelen;
  1251. set_trapsinks(SET_SNMP_TRAP_QUEUELEN,queuelen);
  1253. }
  1254. return 0;
  1256. }
  1258. static int dosnmp_trap_source(argc,argv,u)
  1259. int argc;
  1260. char *argv[];
  1261. struct user *u;
  1262. {
  1263. DEVICE_ETERNAL_ID eternalID;
  1264. DEVICE_ID diID;
  1265. int offset;
  1266. UINT32 ifmask;
  1267. long  rc; /*** sun define 2000.07.28 v0.0.6 ***/
  1268. /* 0 表示不需要创建，~0L表示所有端口类型 */
  1269. #ifdef SWITCH
  1270.     ifmask = INTERFACE_TYPE_MASK_ROUTING;
  1271. #else
  1272.     ifmask = (UINT32)~0L;
  1273. #endif
  1274. if (ARG_NOERR != getinterface(&eternalID, &offset, 0, 
  1275. ifmask, argc, argv, u))
  1276. return -1;
  1277. /* 修正argc和argv的值，1表示子命令 */
  1278. argc -= 1+offset;
  1279. argv += 1+offset;
  1280. /* 将eternalID转换为diID */
  1281. if (INTERFACE_GLOBAL_SUCCESS != interface_omnivorous_callback_makemomentary(&diID, eternalID))
  1282. return -1;
  1283. /* vty_output("diID=%dn",diID); */
  1284. #if 0 /*  2000.03.21   */
  1285. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1286. snmp_para.trapsource = 0;
  1287. set_trapsinks(SET_SNMP_TRAP_SOURCE,0);
  1288. }else{
  1289. snmp_para.trapsource = diID;
  1290. set_trapsinks(SET_SNMP_TRAP_SOURCE,diID);
  1291. }
  1292. #else
  1293.    if ((rc = cmdend(argc, argv, u)))/*** sun define 2000.07.28 ***/
  1294.      return rc;
  1296. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1297. snmp_para.trapsource = DEVICE_INVALID_ETERNAL_ID;
  1298. set_trapsinks(SET_SNMP_TRAP_SOURCE,0);
  1299. }else{
  1300. snmp_para.trapsource = eternalID;
  1301. set_trapsinks(SET_SNMP_TRAP_SOURCE,eternalID);
  1302. }
  1304. #endif /* #if 0 */
  1307. return 0;
  1309. }
  1312. static int dosnmp_trap_timeout(argc,argv,u)
  1313. int argc;
  1314. char *argv[];
  1315. struct user *u;
  1316. {
  1317. int timeout;
  1318.     long rc;/*** sun define 2000.07.28 v0.0.6 ***/
  1319. if(argc==1){
  1320. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1321. snmp_para.timeout = SNMP_DEFAULT_TRAP_TIMEOUT;
  1322. set_trapsinks(SET_SNMP_TRAP_TIMEOUT,SNMP_DEFAULT_TRAP_TIMEOUT*1000000L);/** in set_traplinks() in us unit */
  1324. }else{
  1325. vty_output("snmp trap-timeout %dn",
  1326. snmp_para.timeout);
  1327. }
  1328. return 0;
  1329. }else{
  1330.  switch(getintrc(&timeout, argc,argv,1,SNMP_MAX_TRAP_TIMEOUT,u)){
  1331.          case ARG_NOERR:
  1332.     break;
  1333. case ARG_QUEST :
  1334.          cmderror(ERR_NEXTP, NULL, u);
  1335.     default:
  1336.          return 1;
  1337. }/*switch*/
  1339.      if ((rc = cmdend(argc-2, argv+2, u)))/*** sun define 2000.07.27 v0.0.6***/
  1340.      return rc;
  1342. snmp_para.timeout = (unsigned short)timeout;
  1343. set_trapsinks(SET_SNMP_TRAP_TIMEOUT,timeout*1000000L);/** in set_traplinks() in us unit */
  1344. }
  1345. return 0;
  1347. }
  1350. /*snmp command
  1351. * snmp view ***
  1352. */
  1353. static int dosnmp_view_name(int argc,char *argv[],struct user *u);
  1354. /*static int dosnmp_view_name_sun(int argc,char *argv[],struct user *u);*/
  1355. static void dosnmp_view_delete(char *viewName);
  1356. static int dosnmp_view_type(int argc,char *argv[],struct user *u);
  1357. static int display_snmp_view(void);
  1359. struct cmds snmp_view_cmds[] = {
  1360. { "WORD", MATCH_STR,  cmdPref(PF_CMDNO, 0, 0), 0x1, 
  1361. dosnmp_view_name, NULL,NULL,cmdArgc(2,0,0), cmdArgc(0,0,0), 
  1362. "WORD          --  Name of the view",
  1363. "WORD          --  视图名",
  1364. NULLCHAR,NULLCHAR},
  1365. { (char *)-1, MATCH_END,  0, 0x20, NULL,NULL,NULL,0, 0, 
  1366. "<cr>",
  1367. "结束",
  1368. NULLCHAR ,NULLCHAR},
  1370. {NULLCHAR}
  1372. };
  1373. #if 0
  1374. struct cmds snmp_view_name_cmds[] = {
  1375. { (char *)-1, MATCH_STR,  cmdPref(PF_CMDNO, 0, 0), 0, 
  1376. dosnmp_view_name_sun, NULL,NULL,2, 2, 
  1377. "WORD          --  MIB view family name",
  1378. "WORD          --  MIB 族名字",
  1379. NULLCHAR,NULLCHAR},
  1380. {NULLCHAR}
  1382. };
  1383. #endif
  1384. struct cmds snmp_view_sides_cmds[] = {
  1385. { "excluded", MATCH_AMB,  cmdPref(PF_CMDNO, 0, 0), 0, 
  1386. dosnmp_view_type, NULL,NULL,0, 1, 
  1387. "excluded      --  MIB family is excluded from the view",
  1388. "excluded      --  拒绝该 MIB 族",
  1389. NULLCHAR ,NULLCHAR},
  1390. { "included", MATCH_AMB,  cmdPref(PF_CMDNO, 0, 0), 0, 
  1391. dosnmp_view_type, NULL,NULL,0, 1, 
  1392. "included      --  MIB family is included in the view",
  1393. "included      --  包括该 MIB 族",
  1394. NULLCHAR ,NULLCHAR},
  1396. {NULLCHAR}
  1398. };
  1400. /*** sun define 2000.03.16 ***/
  1401. static int dosnmp_view(int argc,char *argv[],struct user *u)
  1402. {
  1404. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1405. u->cmd_mskbits = 0x2F;
  1406. }else{
  1407. u->cmd_mskbits = 0x1F;
  1408. }
  1410. return subcmd(snmp_view_cmds,&u->cmd_mskbits, argc, argv, u);
  1411. }
  1413. void display_a_view (struct vacm_viewEntry *vp)
  1414. {
  1415. char buf[512];
  1417. if (vp->viewStorageType == SNMP_STORAGE_PERMANENT && vp->viewStatus == SNMP_ROW_ACTIVE)
  1418. {
  1419. if (vp->subtreeName[0] == '')
  1420. {
  1421. sprint_objid(buf,vp->viewSubtree,vp->viewSubtreeLen);
  1422. vty_printf("snmp-server view %s %s %sn",
  1423. vp->viewName+1,translate_objid(buf),
  1424. vp->viewType==VIEW_INCLUDED?"included":"excluded");
  1425. }
  1426. else
  1427. {
  1428. vty_printf("snmp-server view %s %s %sn",
  1429. vp->viewName+1,vp->subtreeName,
  1430. vp->viewType==VIEW_INCLUDED?"included":"excluded");
  1431. }
  1432. }
  1434. }
  1436. static int display_snmp_view(void)
  1437. {
  1439. if (vacm_walkThrViewEntry (display_a_view))
  1440. {
  1441. return FALSE;
  1442. }
  1443. else
  1444. {
  1445. return TRUE;
  1446. }
  1448. }
  1450. static int dosnmp_view_name(int argc,char *argv[],struct user *u)
  1451. {
  1452. SNMP_VIEW view;
  1453. char *name;
  1454. /*** 2000.03.18 test dump_objid ***
  1455. char buf[128];
  1456. ******/
  1458. memset(&view,0,sizeof(SNMP_VIEW));
  1459. u->struct_p[VIEW] = (unsigned long)&view;
  1461. strncpy(view.viewName,argv[0],63);
  1463. view.viewSubtreeLen = 32;/*** sun define 2000.03.17 ***/
  1465. if(IsNoPref(u)){/*no snmp host <hostnameipaddree>*/
  1466. u->cmd_mskbits = 0x2F;
  1467. if(argc<2){
  1468. dosnmp_view_delete(view.viewName);
  1469. return 0;
  1470. }
  1471. }else{
  1472. u->cmd_mskbits = 0x1F;
  1473. }
  1475. switch (getstrrc(&name, argc, argv, 0, NAME_MAXLEN, u)) {
  1476. case ARG_NOERR :
  1477. break;
  1478. case ARG_GENER :
  1479. return -1;
  1480. case ARG_PARAM :
  1481. eng_chi(u, "Incomplete command", "命令不完整");
  1482. return -1;
  1483. case ARG_QUERY :
  1484. eng_chi(u, "  WORD          --  MIB view family name",
  1485. "  WORD          --  MIB 族名字");
  1486. return 1;
  1487. case ARG_QUEST :
  1488. eng_chi(u, "WORD", "WORD");
  1489. return 1;
  1490. default :
  1491. return -1;
  1492. }
  1494. /*** 2000.03.17  ***
  1495. strncpy(viewname,argv[1],MAX_NAME_LEN-1);
  1496. ******/
  1497. if (!ReadObjidFromSubtree (name, view.viewSubtree, &view.viewSubtreeLen))
  1498. {
  1499. if (!read_objid(name,view.viewSubtree, (size_t *)(&view.viewSubtreeLen))){
  1500. vty_output("Illegal subtree oid: %sn",name);
  1501. return -1;
  1502. }
  1503. view.subtreeName[0] = '';
  1504. }
  1505. else
  1506. {
  1507. strcpy (view.subtreeName, name);
  1508. }
  1510. return subcmd(snmp_view_sides_cmds,&u->cmd_mskbits, --argc, ++argv, u);
  1512. }
  1514. #if 0
  1515. static int dosnmp_view_name_sun(int argc,char *argv[],struct user *u)
  1516. {
  1517. SNMP_VIEW *view =(SNMP_VIEW *)u->struct_p[VIEW];
  1519. if (!ReadObjidFromSubtree (argv[0], view->viewSubtree, &view->viewSubtreeLen))
  1520. {
  1521. if (!read_objid(argv[0],view->viewSubtree, (size_t *)(&view->viewSubtreeLen))){
  1522. vty_output("Illegal subtree oid: %sn",argv[0]);
  1523. return -1;
  1524. }
  1525. view->subtreeName[0] = '';
  1526. }
  1527. else
  1528. {
  1529. strcpy (view->subtreeName, argv[0]);
  1530. }
  1532. return subcmd(snmp_view_sides_cmds,&u->cmd_mskbits, argc, argv, u);
  1534. }
  1535. #endif
  1536. static void dosnmp_view_delete(char *viewName)
  1537. {
  1538. int      IsDelete=0;
  1539. struct vacm_viewEntry *vp;
  1540. while (1)
  1541. {
  1542. vp = vacm_findViewEntryByName (viewName);
  1543. if (vp != NULL)
  1544. {
  1545. vacm_destroyViewEntry (vp->viewName+1, vp->viewSubtree, vp->viewSubtreeLen);
  1546. IsDelete = 1;
  1547. }
  1548. else
  1549. {
  1550. break;
  1551. }
  1552. }
  1554. if (!IsDelete)
  1555.   vty_output("Cannot find view %sn",viewName);
  1556. }
  1557. static int dosnmp_view_type(int argc,char *argv[],struct user *u)
  1558. {
  1559. SNMP_VIEW *view =(SNMP_VIEW *)u->struct_p[VIEW];
  1560. struct vacm_viewEntry *vp;
  1561. u_char viewMask[sizeof (vp->viewMask)];
  1562. int i;
  1564. switch((char)*argv[0]){
  1565. case 'i':
  1566. case 'I':
  1567. view->viewType=VIEW_INCLUDED;
  1568. break;
  1569. case 'E':
  1570. case 'e':
  1571. view->viewType=VIEW_EXCLUDED;
  1572. break;
  1574. }
  1575. vp = vacm_getViewEntry (view->viewName, view->viewSubtree, view->viewSubtreeLen);
  1576. if (vp == NULL || vp->viewSubtreeLen != view->viewSubtreeLen)
  1577. {
  1578.      if(IsNoPref(u)){
  1579.          vty_output("%%Error: Can't find snmp viewn");
  1580.          return -1;
  1581.      }
  1582. if ((vp = vacm_createViewEntry(view->viewName, view->viewSubtree, view->viewSubtreeLen)) == NULL)
  1583. {
  1584. eng_chi(u, "failed to create view entry, may be view name to long","创建view entry失败，或许是view的名字太长");
  1585. return -1;
  1586. }
  1587. strcpy (vp->subtreeName, view->subtreeName);
  1589. }
  1590. else
  1591. {
  1592.      if(IsNoPref(u)){
  1593.          if (vp->viewType != view->viewType) {
  1594.              vty_output("%%Error: View type errorn");
  1595.              return -1;
  1596.          }
  1597.          vacm_destroyViewEntry(vp->viewName+1, vp->viewSubtree, vp->viewSubtreeLen);
  1598.          return 0;
  1599.      }
  1600. strcpy (vp->subtreeName, view->subtreeName);
  1601. }
  1603. for (i = 0; i < sizeof(viewMask); i++)
  1604. {
  1605.     viewMask[i] = 0xff;
  1606.     }
  1608. memcpy(vp->viewMask, viewMask, sizeof(viewMask));
  1610.     vp->viewType = view->viewType;
  1611.     vp->viewStorageType = SNMP_STORAGE_PERMANENT;
  1612.     vp->viewStatus = SNMP_ROW_ACTIVE;
  1614. return 0;
  1616. }
  1618. extern ULONG snmp_source_ip;
  1619. extern int change_session_sourceaddr(uint32 source_ip_addr);
  1620. int dosnmp_srcipaddr(int argc, char *argv[], struct user *u)
  1621. {
  1623. ULONG ipaddr;
  1624.        long rc;
  1625. int i;
  1627.   if(IsNoPref(u))
  1628. {
  1629. if (cmdend (argc - 1, argv + 1, u))
  1630. return -1;
  1631. else {
  1632.  ipaddr = INADDR_ANY;
  1633.  goto do_it;
  1634. }
  1635. }
  1636.   
  1637. if(argc ==1){
  1639. cmderror(ERR_INCOM, argv[0], u);
  1640. return -1;
  1641. }
  1642. else{
  1643. i = getaddress(&ipaddr, argc, argv, u);
  1644. switch(i){
  1645. case ARG_QUEST:
  1646. case ARG_QUERY:
  1647. eng_chi(u, "A.B.C.D              -- Source IP Address", "A.B.C.D              -- Source IP Address");
  1648. return 1;
  1649. case ARG_GENER:
  1650. case ARG_PARAM:
  1651. return i;
  1652. }
  1653. }
  1655. if ((rc = cmdend(argc-2, argv+2, u)))
  1656. return rc;
  1657. do_it:
  1658. if  (snmp_source_ip !=ipaddr)
  1659. {
  1660. if (ipaddr!=INADDR_ANY) 
  1661. { 
  1662. DEVICE_ID ifid;
  1663. ifid= if_withaddr(ipaddr);
  1664. if  (ifid ==0) {
  1665.   vty_output("%s is not local ip addressn",snmp_ntoa(ipaddr));
  1666. return -1;
  1667.  }
  1668. }
  1669. snmp_source_ip= ipaddr;
  1670. change_session_sourceaddr(snmp_source_ip);
  1671. }
  1672. return 0;
  1673. }
  1676. static int dosnmp_trace_error(int argc,char *argv[],struct user *u);/*** sun define 2000.07.11 ***/
  1677. static int dosnmp_trace_event(int argc,char *argv[],struct user *u);
  1678. static int dosnmp_trace_packet(int argc,char *argv[],struct user *u);
  1680. extern int verbose;
  1681. extern int snmp_dump_packet;
  1682. void display_snmp_trap(void);
  1684. struct cmds debug_snmp_cmds[] = {
  1685. { "snmp", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, dosnmp_trace, NULL, NULL, cmdArgc(0,1,0), cmdArgc(0,1,0), 
  1686. "snmp       -- debug SNMP information", 
  1687. "snmp       -- 跟踪 SNMP 信息", 
  1688. NULLCHAR, NULLCHAR  },
  1689. { NULLCHAR }
  1690. };
  1692. struct cmds snmp_trace_cmds[] = {
  1693. { "error", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x01, 
  1694. dosnmp_trace_error,NULL,NULL, 0, 0, 
  1695. "error            --  SNMP error information", 
  1696. "error            --  SNMP 错误信息", 
  1697.   NULLCHAR,NULLCHAR},
  1698. { "event", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x02,
  1699. dosnmp_trace_event,NULL,NULL, 0, 0, 
  1700. "event            --  SNMP event", 
  1701. "event            --  SNMP 事件", 
  1702.   NULLCHAR,NULLCHAR},
  1703. { "packet", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0x04,
  1704. dosnmp_trace_packet,NULL,NULL,  0, 0,
  1705. "packet           --  SNMP packet",
  1706. "packet           --  SNMP 报文", 
  1707.   NULLCHAR,NULLCHAR},
  1709. { (char *)-1, MATCH_END,  0, 0x10, 
  1710. NULL,NULL,NULL,0, 0, 
  1711. "<cr>",
  1712. "<cr>",
  1713. NULLCHAR ,NULLCHAR},
  1714. {NULLCHAR}
  1715. };
  1716. extern void snmp_set_dump_verbose (int );
  1717. extern int output_error;
  1719. void snmp_no_debug (void )
  1720. {
  1721. SNMPtrace = 0;
  1722. verbose = 0;
  1723. snmp_dump_packet = 0;
  1724. }
  1726. void snmp_show_debug (uint32 debug_flag)
  1727. {
  1728. if  (SNMPtrace!=0){
  1729. vty_output ("SNMP:n");
  1730. if (SNMPtrace & SNMP_DEBUG_ERROR)
  1731. vty_output("  SNMP error debugging is onn");
  1732. if (SNMPtrace & SNMP_DEBUG_EVENT)
  1733. vty_output("  SNMP event debugging is onn");
  1734. if (SNMPtrace & SNMP_DEBUG_PACKETS)
  1735. vty_output("  SNMP packet debugging is onn");
  1736. }
  1737. }
  1738. static int dosnmp_trace(int argc,char *argv[],struct user *u)
  1739. {
  1741. if (argc<2)
  1742. {
  1743. if(IsNoPref(u)){/*no snmp host argv[0]*/
  1744. SNMPtrace = 0;
  1745.      verbose = 0;
  1746. snmp_dump_packet = 0;
  1747. set_trace_flag(MODULE_TYPE_SNMP,0xffffffff,snmp_show_debug,snmp_no_debug, 0);    
  1748. }else{
  1749. /*display_snmp_trap();*/
  1750. /*yangyuhua(m) 2006-4-24*/
  1751. u->struct_p[3] |=(SNMP_DEBUG_ERROR | (SNMP_DEBUG_EVENT|SNMP_DEBUG_VERBOSE) | SNMP_DEBUG_PACKETS);
  1752. SNMPtrace = (unsigned short)(u->struct_p[2]|u->struct_p[3]);
  1753. snmp_set_dump_verbose (SNMPtrace & SNMP_DEBUG_VERBOSE);
  1754.      verbose = SNMPtrace & SNMP_DEBUG_VERBOSE;
  1755. snmp_set_dump_packet(SNMPtrace & SNMP_DEBUG_PACKETS);
  1756. set_trace_flag(MODULE_TYPE_SNMP,SNMPtrace,snmp_show_debug, snmp_no_debug,1);    
  1757. output_error = SNMPtrace & SNMP_DEBUG_ERROR;
  1758. }
  1759. return 0;
  1760. }
  1762. u->cmd_mskbits = 0x1F;
  1763. u->struct_p[2] = SNMPtrace;/*reserve origin */
  1764. u->struct_p[3] = 0;      /*command modify*/
  1765.     if (subcmd(snmp_trace_cmds, &u->cmd_mskbits, argc, argv, u)==0){
  1766.      SNMPtrace = (unsigned short)(u->struct_p[2]|u->struct_p[3]);
  1767. snmp_set_dump_verbose (SNMPtrace & SNMP_DEBUG_VERBOSE);
  1768.      verbose = SNMPtrace & SNMP_DEBUG_VERBOSE;
  1769. snmp_set_dump_packet(SNMPtrace & SNMP_DEBUG_PACKETS);
  1770. set_trace_flag(MODULE_TYPE_SNMP,SNMPtrace,snmp_show_debug, snmp_no_debug,1);    
  1771. output_error = SNMPtrace & SNMP_DEBUG_ERROR;
  1772.     }
  1773.       return 0;
  1776. }
  1778. void display_snmp_trap(void)
  1779. {
  1780. if  (SNMPtrace!=0){
  1781. vty_output("snmp-server trace");
  1782. if (SNMPtrace & SNMP_DEBUG_ERROR)
  1783. vty_output(" error");/*v0.0.3*/
  1784. if (SNMPtrace & SNMP_DEBUG_EVENT)
  1785. vty_output(" event");/*v0.0.3*/
  1786. if (SNMPtrace & SNMP_DEBUG_PACKETS)
  1787. vty_output(" packet");
  1788. vty_output("n");
  1789. }else{
  1790. vty_output("Nonen");
  1791. }
  1792. }
  1793. static int dosnmp_trace_error(int argc,char *argv[],struct user *u)
  1794. {
  1795.   u->struct_p[3] |= SNMP_DEBUG_ERROR;
  1796.  
  1797.     if (argc>1){
  1798.      return subcmd(snmp_trace_cmds, &u->cmd_mskbits, argc, argv, u);
  1799.     }
  1800.     return 0;
  1802. }
  1805. static int dosnmp_trace_event(int argc,char *argv[],struct user *u)
  1806. {
  1807.   u->struct_p[3] |= (SNMP_DEBUG_EVENT|SNMP_DEBUG_VERBOSE);
  1808.  
  1809.     if (argc>1){
  1810.      return subcmd(snmp_trace_cmds, &u->cmd_mskbits, argc, argv, u);
  1811.     }
  1812.     return 0;
  1814. }
  1816. static int dosnmp_trace_packet(int argc,char *argv[],struct user *u)
  1817. {
  1818.   u->struct_p[3] |= SNMP_DEBUG_PACKETS;
  1819.  
  1820.     if (argc>1){
  1821.      return subcmd(snmp_trace_cmds, &u->cmd_mskbits, argc, argv, u);
  1822.     }
  1823.     return 0;
  1825. }
  1827. BOOL do_showrunning_snmpv3_remote_engineID();
  1828. long snmp_showrunning(DEVICE_ID diID)
  1829. {
  1830. char    *pstrName=NULLCHAR;
  1831. int    emptyconfiguration = TRUE;
  1832. #ifdef INCLUDE_SNMPV3
  1833.     emptyconfiguration = 
  1834.         do_showrunning_snmpv3_remote_engineID()&&emptyconfiguration;
  1836.     emptyconfiguration = display_snmp_group()&&emptyconfiguration;
  1838.     emptyconfiguration = display_snmp_user()&&emptyconfiguration;
  1839. #endif
  1840.     emptyconfiguration = display_snmp_community()&&emptyconfiguration;
  1842. if(snmp_para.syscontact[0]){
  1843. vty_printf("snmp-server contact ");
  1844. if(isquotation(snmp_para.syscontact))
  1845.     vty_printf(""");
  1846. vty_printf("%s",snmp_para.syscontact);
  1847. if(isquotation(snmp_para.syscontact))
  1848.     vty_printf(""");
  1849.     vty_printf("n");
  1850. emptyconfiguration = FALSE;
  1851. }
  1853. emptyconfiguration = display_snmp_host()&&emptyconfiguration;
  1855. if(snmp_para.syslocation[0]){
  1856. vty_printf("snmp-server location ");
  1857. if(isquotation(snmp_para.syslocation))
  1858.     vty_printf(""");
  1859. vty_printf("%s",snmp_para.syslocation);
  1860. if(isquotation(snmp_para.syslocation))
  1861.     vty_printf(""");
  1862.     vty_printf("n");
  1864. emptyconfiguration = FALSE;
  1865.     }
  1866. if(snmp_para.packetsize!=SNMP_DEFAULT_PACKETSIZE){
  1867. vty_printf("snmp-server packetsize %dn",snmp_para.packetsize);
  1868. emptyconfiguration = FALSE;
  1869. }
  1872. if(snmp_para.queuelen!=SNMP_DEFAULT_TRAP_QUEUELEN){
  1873. vty_printf("snmp-server queue-length %dn",snmp_para.queuelen);
  1874. emptyconfiguration = FALSE;
  1875. }
  1878. if(snmp_para.trapsource!=DEVICE_INVALID_ETERNAL_ID){
  1879. interface_omnivorous_callback_newgetname(snmp_para.trapsource, &pstrName);
  1880. vty_printf("snmp-server trap-source %sn",pstrName);
  1881. emptyconfiguration = FALSE;
  1882. if(pstrName)
  1883.      sys_mem_free(pstrName);
  1884. }
  1886. if(snmp_para.timeout!=SNMP_DEFAULT_TRAP_TIMEOUT){
  1887. vty_printf("snmp-server trap-timeout %dn",snmp_para.timeout);
  1888. emptyconfiguration = FALSE;
  1889. }
  1891. if(snmp_source_ip!=0){
  1892. vty_printf("snmp-server source-addr %sn",snmp_ntoa(snmp_source_ip));
  1893. emptyconfiguration = FALSE;
  1894. }
  1895. emptyconfiguration = display_snmp_view()&&emptyconfiguration;
  1897.     if(emptyconfiguration)
  1898.         return INTERFACE_DEVICE_ERROR_EMPTYCONFIGURATION;
  1899.     else
  1900.      return INTERFACE_GLOBAL_SUCCESS;
  1903. }
  1905. /*SunXi added for BCMP*/
  1906. #ifdef INCLUDE_BCMP
  1907. static char *_snmp_bcmp_cfg_buffer;
  1908. static int  _snmp_bcmp_cfg_pos, _snmp_bcmp_cfg_max;
  1909. static int32 snmp_bcmp_vty_rio_fun(char* buffer,int len)
  1910. {
  1911.     if (_snmp_bcmp_cfg_max <= _snmp_bcmp_cfg_pos + len)
  1912.     {
  1913.         _snmp_bcmp_cfg_buffer[_snmp_bcmp_cfg_pos] = 0;
  1914.         _snmp_bcmp_cfg_pos = _snmp_bcmp_cfg_max ;
  1915.         return 0;
  1916.     }
  1918.     memcpy(&_snmp_bcmp_cfg_buffer[_snmp_bcmp_cfg_pos], buffer, len);
  1919.     _snmp_bcmp_cfg_pos += len;
  1920.     _snmp_bcmp_cfg_buffer[_snmp_bcmp_cfg_pos] = 0;
  1921.     return len;
  1922. }
  1923. int snmp_bcmp_config(char *buffer, size_t size)
  1924. {
  1925.     union vty_output_attribute param, old;
  1926.     _snmp_bcmp_cfg_pos = 0;
  1927.     _snmp_bcmp_cfg_max = size;
  1928.     _snmp_bcmp_cfg_buffer = buffer;
  1929.     _snmp_bcmp_cfg_buffer[0] = 0;
  1930.     param.rio.rflag = RIO_CUSTOM;
  1931.     param.rio.u.function =snmp_bcmp_vty_rio_fun;
  1932.     /*save old redirection*/
  1933.     vty_output_ctrl(VTY_OUTPUT_GET_REDIRECT, &old);
  1934.     vty_output_ctrl(VTY_OUTPUT_SET_REDIRECT, &param);
  1935.     /*get config*/
  1936.     display_snmp_community();
  1937.     display_snmp_view();
  1938.     /*restore old redirection*/
  1939.     vty_output_ctrl(VTY_OUTPUT_SET_REDIRECT, &old);
  1940.     return strlen(_snmp_bcmp_cfg_buffer);
  1941. }
  1942. #endif
  1944. int do_show_snmp(int argc, char *argv[], struct user *u);
  1945. int do_show_snmp_host(int argc, char *argv[], struct user *u);
  1946. int do_show_snmp_view(int argc, char *argv[], struct user *u);
  1947. extern void show_snmp(void);
  1948. extern void show_snmp_host(void);
  1950. struct cmds snmp_show_cmds[] = {
  1951. { "snmp", MATCH_AMB, 0, 0, do_show_snmp, NULL, NULL, 0, 0, 
  1952. "snmp          - SNMP statistics", 
  1953. "snmp          - SNMP 统计信息", 
  1954. NULLCHAR, NULLCHAR 
  1955. },
  1956. { NULLCHAR }
  1957. };
  1958. struct cmds snmp_show_host_cmds[] = {
  1959. #ifdef INCLUDE_SNMPV3
  1960. { "engineID", MATCH_AMB, 0, 0, do_show_snmp_engineID, NULL, NULL, 0, 1,
  1961. "engineID      - show SNMP engine information", 
  1962. "engineID      - SNMP 引擎信息",
  1963. NULLCHAR, NULLCHAR
  1964. },
  1965. { "group", MATCH_AMB, 0, 0, do_show_snmp_group, NULL, NULL, 0, 1,
  1966. "group         - show SNMP group information", 
  1967. "group         - SNMP 组信息",
  1968. NULLCHAR, NULLCHAR
  1969. },
  1970. #endif
  1971. { "host", MATCH_AMB, 0, 0, do_show_snmp_host, NULL, NULL, 0, 1,
  1972. "host          - show SNMP trap hosts", 
  1973. "host          - SNMP 陷阱主机信息",
  1974. NULLCHAR, NULLCHAR
  1975. },
  1976. { "view", MATCH_AMB, 0, 0, do_show_snmp_view, NULL, NULL, 0, 1,
  1977. "view          - show SNMP views", 
  1978. "view          - SNMP 视图信息",
  1979. NULLCHAR, NULLCHAR
  1980. },
  1981. #ifdef INCLUDE_SNMPV3
  1982. { "user", MATCH_AMB, 0, 0, do_show_snmp_user, NULL, NULL, 0, 1,
  1983. "user          - show SNMP group information", 
  1984. "user          - SNMP 组信息",
  1985. NULLCHAR, NULLCHAR
  1986. },
  1987. #endif
  1988. { (char *)-1, MATCH_END,  0, 0, 
  1989. NULL,NULL,NULL,0, 0, 
  1990. "<cr>",
  1991. "结束",
  1992. NULLCHAR ,NULLCHAR},
  1993. {NULLCHAR}
  1994. };
  1996. int do_show_snmp(int argc, char *argv[], struct user *u)
  1997. {
  1998. if (argc <= 1)
  1999. {
  2000. show_snmp();
  2001. }
  2002. else
  2003. {
  2004.       return subcmd(snmp_show_host_cmds, &u->cmd_mskbits, argc, argv, u);
  2005. }
  2006. return 0;
  2007. }
  2008. int do_show_snmp_host(int argc, char *argv[], struct user *u)
  2009. {
  2010. show_snmp_host();
  2011. return 0;
  2012. }
  2013. void display_view (struct vacm_viewEntry *vp)
  2014. {
  2015. char buf[512], buf1[128], buf2[16];
  2016. int len;
  2018. if (vp->viewMaskLen == 0)
  2019. strcpy (buf1, "-");
  2020. else
  2021. {
  2022. sprintf (buf1, "%X", vp->viewMask[0]);
  2023. for (len = 1; len < vp->viewMaskLen; len ++)
  2024. {
  2025. sprintf (buf2, ":%X", vp->viewMask[len]);
  2026. }
  2027. }
  2028. sprint_objid(buf,vp->viewSubtree,vp->viewSubtreeLen);
  2029. vty_printf("%s %s %s %s %s %sn",
  2030. vp->viewName+1,translate_objid(buf), buf1,
  2031. vp->viewType==VIEW_INCLUDED?"included":"excluded",snmp_storage_trans[vp->viewStorageType],
  2032. snmp_status_trans[vp->viewStatus]);
  2034. }
  2035. int do_show_snmp_view(int argc, char *argv[], struct user *u)
  2036. {
  2037. if (vacm_walkThrViewEntry (display_view))
  2038. {
  2039. vty_printf_end(1);
  2040. }
  2041. else
  2042. {
  2043. vty_printf ("Nonen");
  2044. vty_printf_end(1);
  2045. }
  2046. return 0;
  2047. }
  2049. /*copied and modified from vacm_parse_access, file snmplibvacm.c
  2050.   Sunxi, Feb 23, 2004, for SNMPv3*/
  2051. void vacm_parse_access_bdcom(const char *name, int model, int level, 
  2052.                     const char *readview, const char *writeview, const char *notifyview,
  2053.                     const char *ipacl)
  2054. {
  2055.     struct vacm_accessEntry *ap;
  2057.     if (model != SNMP_SEC_MODEL_ANY &&
  2058.         model != SNMP_SEC_MODEL_SNMPv1 &&
  2059.         model != SNMP_SEC_MODEL_SNMPv2c &&
  2060.         model != SNMP_SEC_MODEL_USM) {
  2061.      vty_output("%%Error: bad security model (any, v1, v2c, usm)n");
  2062.      return;
  2063.     }
  2064.     if (level != SNMP_SEC_LEVEL_NOAUTH &&
  2065.         level != SNMP_SEC_LEVEL_AUTHNOPRIV &&
  2066.         level != SNMP_SEC_LEVEL_AUTHPRIV) {
  2067.      vty_output("%%Error: bad security level (noauthnopriv, authnopriv, authpriv)n");
  2068.      return;
  2069.     }
  2071.     if (readview != NULL && strlen(readview)+1 > sizeof(ap->readView)) {
  2072.      vty_output("%%Error: readView too longn");
  2073.         return;
  2074.     }
  2075.     if (writeview != NULL && strlen(writeview)+1 > sizeof(ap->writeView)) {
  2076.      vty_output("%%Error: writeView too longn");
  2077.         return;
  2078.     }
  2079.     if (notifyview != NULL && strlen(notifyview)+1 > sizeof(ap->notifyView)) {
  2080.      vty_output("%%Error: notifyView too longn");
  2081.         return;
  2082.     }
  2083.     if (ipacl != NULL && strlen(ipacl)+1 > sizeof(ap->access_list)) {
  2084.      vty_output("%%Error: ip access list too longn");
  2085.         return;
  2086.     }
  2088.     ap = vacm_getAccessEntry(name, "", model, SNMP_SEC_LEVEL_AUTHPRIV);
  2089.     if (ap == NULL) {
  2090.         ap = vacm_createAccessEntry (name, "", model, level);
  2091.         if (!ap) {
  2092.      vty_output("%%Error: failed to create access entryn");
  2093.      return;
  2094.         }
  2095.     } else {
  2096.         ap->readView[0] = 0;
  2097.         ap->writeView[0] = 0;
  2098.         ap->notifyView[0] = 0;
  2099.         ap->access_list[0] = 0;
  2100.         ap->securityLevel = level;
  2101.         ap->securityModel = model;
  2102.     }
  2103.     strcpy(ap->readView, readview);
  2104.     if (writeview != NULL)
  2105.         strcpy(ap->writeView, writeview);
  2106.     if (notifyview != NULL)
  2107.         strcpy(ap->notifyView, notifyview);
  2108.     if (ipacl != NULL)
  2109.         strcpy(ap->access_list, ipacl);
  2110.     ap->contextMatch = CONTEXT_MATCH_EXACT;
  2111.     ap->storageType = SNMP_STORAGE_NONVOLATILE;
  2112.     ap->status = SNMP_ROW_ACTIVE;
  2113.     free (ap->reserved);
  2114.     ap->reserved = NULL;
  2115. }
  2117. /*copied and modified from vacm_parse_group, file snmplibvacm.c
  2118.   Sunxi, Feb 23, 2004, for SNMPv3*/
  2119. void vacm_parse_group_bdcom(const char *group, const char *security, int model)
  2120. {
  2121.     struct vacm_groupEntry *gp;
  2123.     if (group == NULL || *group == 0) {
  2124. vty_output("%%Error: missing GROUP parametern");
  2125. return;
  2126.     }
  2127.     if (security == NULL || *security == 0) {
  2128. vty_output("%%Error: missing SECURITY parametern");
  2129. return;
  2130.     }
  2131.     if (model != SNMP_SEC_MODEL_SNMPv1 &&
  2132.         model != SNMP_SEC_MODEL_SNMPv2c &&
  2133.         model != SNMP_SEC_MODEL_USM) {
  2134. vty_output("%%Error: bad security model, should be: v1, v2c or usmn");
  2135. return;
  2136.     }
  2137.     if (strlen(security)+1 > sizeof(gp->groupName)) {
  2138.      vty_output("%%Error: security name too longn");
  2139. return;
  2140.     }
  2142.     /*destroy the old one*/
  2143.     gp = vacm_getGroupEntry(model, security);
  2144.     if (gp == NULL) {
  2145.         gp = vacm_createGroupEntry(model, security);
  2146.         if (!gp) {
  2147.      vty_output("%%Error: failed to create group entryn");
  2148.      return;
  2149.         }
  2150.     }
  2151.     strcpy (gp->groupName, group);
  2152.     gp->storageType = SNMP_STORAGE_PERMANENT;
  2153.     gp->status = SNMP_ROW_ACTIVE;
  2154.     free (gp->reserved);
  2155.     gp->reserved = NULL;
  2156. }
  2159. /*copied and modified from usm_parse_config_usmUser, file snmplibsnmpusm.c
  2160.   Sunxi, Feb 24, 2004, for SNMPv3*/
  2161. struct usmUser *
  2162. usm_parse_config_user_bdcom(const char * name, 
  2163.         oid * authProtocol, size_t authProtocolLen, 
  2164.         oid * privProtocol, size_t privProtocolLen,
  2165.         char *password,
  2166.         char *snmpEngineID, size_t snmpEngineIDLen)
  2167. {
  2168.   struct usmUser *user;
  2169.   int ret;
  2170.   u_char   userKey[SNMP_MAXBUF_SMALL];
  2171.   size_t   userKeyLen = SNMP_MAXBUF_SMALL;
  2173.   user = usm_create_initial_user(name, authProtocol, authProtocolLen, privProtocol, privProtocolLen);
  2174.   if (user == NULL)
  2175.     return NULL;
  2177.   if (snmpEngineID != NULL) {
  2178.       if (user->engineIDLen < snmpEngineIDLen) {
  2179.         free(user->engineID);
  2180.         user->engineID = malloc(user->engineIDLen);
  2181.       } else {
  2182.         memset(user->engineID, 0, user->engineIDLen);
  2183.       }
  2184.       memcpy(user->engineID, snmpEngineID, snmpEngineIDLen);
  2185.       user->engineIDLen = snmpEngineIDLen;
  2186.   }
  2188.   SNMP_FREE(user->cloneFrom);
  2189.   user->cloneFrom = NULL;
  2190.   user->cloneFromLen = 0;
  2192.   if (password != NULL && strlen(password) != 0) {
  2193.       ret = generate_Ku(user->authProtocol, user->authProtocolLen,
  2194.          (u_char *)password, strlen(password),
  2195.          userKey, &userKeyLen );
  2196.       if (ret != SNMPERR_SUCCESS) {
  2197.         vty_output("%%Error: Generating auth key from pass phrase.n");
  2198.         usm_free_user(user);
  2199.         return NULL;
  2200.       }
  2201.       user->authKeyLen =
  2202.         sc_get_properlength(user->authProtocol, user->authProtocolLen);
  2203.       user->authKey = (u_char *) malloc(user->authKeyLen);
  2204.       ret = generate_kul(user->authProtocol, user->authProtocolLen,
  2205.           user->engineID, user->engineIDLen,
  2206.           userKey, userKeyLen,
  2207.           user->authKey, &user->authKeyLen );
  2208.       if (ret != SNMPERR_SUCCESS) {
  2209.         vty_output("%%Error: Generating auth key from pass phrase.n");
  2210.         usm_free_user(user);
  2211.         return NULL;
  2212.       }
  2214.       user->privKey = (u_char *) malloc(user->authKeyLen);
  2215.       user->privKeyLen = user->authKeyLen;
  2216.       memcpy(user->privKey, user->authKey, user->privKeyLen);
  2218.   }
  2220.   user->userPublicString = NULL;
  2221.   user->userStorageType = ST_NONVOLATILE;
  2223.   user->password_plaintext = strdup(password);
  2225.   return user;
  2226. }
  2229. /*create ucd_snmpv3 access control structs with community name
  2230. copied by sxf from ucd_snmpv3 function vacm_parse_simple(vacm_vars.c)*/
  2231. static void CreateSnmpComm (SNMP_COMMUNITY *snmp_para_comm)
  2232. {
  2233. char *theoid = ".1.3.6.1";
  2234. char *authType = "noauth";
  2235. char *addressname = "default";
  2236. char rw[SNMP_MAX_COMMUNITY_LEN+16];
  2237. char line[3*SNMP_MAX_COMMUNITY_LEN];
  2238. struct vacm_securityEntry *vp;
  2240. /*if the entry exists, delete it and then insert a new entry*/
  2241. vacm_DestroyCommunity (snmp_para_comm->name);
  2243. strcpy (rw, "none");
  2244. if (snmp_para_comm->privilege == READWRITE)
  2245. {
  2246. if ((snmp_para_comm->viewname)[0] == '')
  2247. {
  2248. sprintf (rw, "__vn%s", snmp_para_comm->name);
  2249. }
  2250. else
  2251. {
  2252. strcpy (rw, snmp_para_comm->viewname);
  2253. }
  2254. }
  2256. /*add security virtual name*/
  2257.     sprintf(line,"__sn%s %s %s", snmp_para_comm->name, addressname, snmp_para_comm->name);
  2258.     vacm_parse_security("com2sec",line);
  2259.  
  2260. /*add virtual group name*/
  2261. sprintf(line,"__gn%s v1 __sn%s", snmp_para_comm->name, snmp_para_comm->name);
  2262.     vacm_parse_group("group",line);
  2263.     sprintf(line,"__gn%s v2c __sn%s", snmp_para_comm->name, snmp_para_comm->name);
  2264.     vacm_parse_group("group",line);
  2266. /*add virtual view if viewname is NULL*/
  2267. if ((snmp_para_comm->viewname)[0] == '')
  2268. {
  2269. sprintf(line,"__vn%s included %s", snmp_para_comm->name, theoid);
  2270. vacm_parse_view("view",line);
  2272. /*create virtual access*/
  2273. sprintf(line, "__gn%s  "" any %s exact __vn%s %s %s", snmp_para_comm->name,
  2274.           authType, snmp_para_comm->name, rw, rw);
  2275. vacm_parse_access("access",line);
  2277. }
  2278. else
  2279. {
  2280. /*create virtual access*/
  2281. sprintf(line, "__gn%s  "" any %s exact %s %s %s", snmp_para_comm->name,
  2282.           authType, snmp_para_comm->viewname, rw, rw);
  2283. vacm_parse_access("access",line);
  2284. }
  2285. if ((vp = vacm_FindSecEntryByCommName (snmp_para_comm->name)) != NULL)
  2286. {
  2287. strcpy (vp->access_list, snmp_para_comm->access_list);
  2288. strcpy (vp->viewname, snmp_para_comm->viewname);
  2289. vp->privilege = snmp_para_comm->privilege;
  2290. }
  2292. }
  2294. #ifdef INCLUDE_SNMPV3
  2295. /*
  2296.  *  snmpv3 group commands
  2297.  *  u->struct_p[0]: SNMP Security Modely, ie., SNMP version
  2298.  *  u->struct_p[1]: for version 3: authPriv or authNoPriv or NoAuthNoPriv;
  2299.  *                  for other version, not use
  2300.  *  u->struct_p[2]: access list
  2301.  *  u->struct_p[3]: notify view
  2302.  *  u->struct_p[4]: read view
  2303.  *  u->struct_p[5]: write view
  2304.  *  
  2305.  */
  2306. #define SNMPV3_GROUP_VER_INDEX 0
  2307. #define SNMPV3_GROUP_AP_INDEX 1
  2308. #define SNMPV3_GROUP_ACL_INDEX 2
  2309. #define SNMPV3_GROUP_NOTIFY_INDEX 3
  2310. #define SNMPV3_GROUP_READ_INDEX 4
  2311. #define SNMPV3_GROUP_WRITE_INDEX 5
  2313. #define SNMPV3_GROUP_VIEW_NOTIFY    0x01
  2314. #define SNMPV3_GROUP_VIEW_READ      0x02
  2315. #define SNMPV3_GROUP_VIEW_WRITE     0x04
  2316. #define SNMPV3_GROUP_ACL            0x08
  2318. static int dosnmp_group_acl(int argc,char *argv[],struct user *u);
  2319. static int dosnmp_group_view(int argc,char *argv[],struct user *u);
  2321. static struct cmds snmp_group_view_access_cmds[] = {
  2322. { "access", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_GROUP_ACL,
  2323. dosnmp_group_acl,NULL,NULL, 0, 0, 
  2324. "access           --  specify an access-list associated with this group",
  2325. "access           --  为该组指定访问控制列表", 
  2326.   NULLCHAR,NULLCHAR
  2327. },
  2328. { "notify", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_GROUP_VIEW_NOTIFY,
  2329. dosnmp_group_view,NULL,NULL, 0, 0, 
  2330. "notify           --  specify a notify view for the group", 
  2331. "notify           --  为该组指定通知视图", 
  2332.   NULLCHAR,NULLCHAR
  2333. },
  2334. { "read", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_GROUP_VIEW_READ,
  2335. dosnmp_group_view,NULL,NULL, 0, 0, 
  2336. "read             --  specify a read view for the group", 
  2337. "read             --  为该组指定读操作视图", 
  2338.   NULLCHAR,NULLCHAR
  2339. },
  2340. { "write", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_GROUP_VIEW_WRITE,
  2341. dosnmp_group_view,NULL,NULL, 0, 0, 
  2342. "write            --  specify a write view for the group",
  2343. "write            --  为该组指定写操作视图",
  2344.   NULLCHAR,NULLCHAR
  2345. },
  2346. { DUMMYSTR, MATCH_END, cmdPref(0, 0, 0), 0,
  2347. NULL,NULL,NULL, 0, 0, 
  2348. "<cr>",
  2349. "<cr>",
  2350.   NULLCHAR,NULLCHAR
  2351. },
  2353. { NULLCHAR }
  2354. };
  2356. static int dosnmp_group_acl(int argc,char *argv[],struct user *u)
  2357. {
  2358.     char *name;
  2360. switch(getstrrc(&name,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2361. case ARG_NOERR:
  2362.     break;
  2363.     case ARG_QUEST:
  2364.     case ARG_QUERY:
  2365.         eng_chi(u,  "  WORD    --  Name of access list",
  2366.                         "  WORD    --  访问列表的名字");
  2367.         return 1;
  2368.      case ARG_PARAM :
  2369.      cmderror(ERR_NEXTP, NULL, u);
  2370.      return -1;
  2371.     case ARG_QPART:
  2372. case ARG_GENER:
  2373.     default:
  2374.      return -1;
  2375. }
  2377. u->struct_p[SNMPV3_GROUP_ACL_INDEX] = (int)name;
  2379.     if (argc > 1)
  2380.     return subcmd(snmp_group_view_access_cmds, &u->cmd_mskbits, argc, argv, u);
  2381.     else
  2382.         return 0;
  2383. }
  2385. static int dosnmp_group_view(int argc,char *argv[],struct user *u)
  2386. {
  2387.     char *name;
  2388.     int index;
  2390.     switch ((char)*argv[0])
  2391.     {
  2392.     case 'n':case 'N':
  2393.         index = SNMPV3_GROUP_NOTIFY_INDEX;
  2394.         break;
  2395.     case 'r':case 'R':
  2396.         index = SNMPV3_GROUP_READ_INDEX;
  2397.         break;
  2398.     case 'w':case 'W':
  2399.         index = SNMPV3_GROUP_WRITE_INDEX;
  2400.         break;
  2401.     default:
  2402.         assert(0);
  2403.     }
  2405. switch(getstrrc(&name,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2406. case ARG_NOERR:
  2407.     break;
  2408.     case ARG_QUEST:
  2409.     case ARG_QUERY:
  2410.         eng_chi(u,  "  WORD    --  Name of view",
  2411.                         "  WORD    --  视图的名字");
  2412.         return 1;
  2413.      case ARG_PARAM :
  2414.      cmderror(ERR_NEXTP, NULL, u);
  2415.      return -1;
  2416.     case ARG_QPART:
  2417. case ARG_GENER:
  2418.     default:
  2419.      return -1;
  2420. }
  2422.     u->struct_p[index] = (unsigned long)name;
  2424.     if (argc > 1)
  2425.     return subcmd(snmp_group_view_access_cmds, &u->cmd_mskbits, argc, argv, u);
  2426.     else
  2427.         return 0;
  2428. }
  2430. #define SNMPV3_GROUP_AUTHNOPRIV     0x01
  2431. #define SNMPV3_GROUP_NOAUTHNOPRIV   0x02
  2432. #define SNMPV3_GROUP_AUTHPRIV       0x04
  2434. static int dosnmp_group_authpriv_para(int argc,char *argv[],struct user *u)
  2435. {
  2436.     if ((u->cmd_mskbits & SNMPV3_GROUP_AUTHNOPRIV) == 0)
  2437.     {
  2438.         u->struct_p[SNMPV3_GROUP_AP_INDEX] = SNMP_SEC_LEVEL_AUTHNOPRIV;
  2439.     }
  2440.     else if ((u->cmd_mskbits & SNMPV3_GROUP_NOAUTHNOPRIV) == 0)
  2441.     {
  2442.         u->struct_p[SNMPV3_GROUP_AP_INDEX] = SNMP_SEC_LEVEL_NOAUTH;
  2443.     }
  2444.     else if ((u->cmd_mskbits & SNMPV3_GROUP_AUTHPRIV) == 0)
  2445.     {
  2446.         u->struct_p[SNMPV3_GROUP_AP_INDEX] = SNMP_SEC_LEVEL_AUTHPRIV;
  2447.     }
  2449.     if (IsNoPref(u)) {
  2450.         int rc;
  2451.         if ((rc = cmdend(--argc, ++argv, u)))
  2452.             return rc;
  2453.         return 0;
  2454.     }
  2456.     u->cmd_mskbits = -1;
  2457.     if (argc > 1)
  2458.     return subcmd(snmp_group_view_access_cmds, &u->cmd_mskbits, argc, argv, u);
  2459.     else
  2460.         return 0;
  2461. }
  2464. static struct cmds snmp_group_authpriv_cmds[] = {
  2465. { "auth", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_AUTHNOPRIV,
  2466. dosnmp_group_authpriv_para,NULL,NULL, 0, 0, 
  2467. "auth             --  Specifies authentication of a packet without encrypting it",
  2468. "auth             --  该组需要认证但不加密",
  2469.   NULLCHAR,NULLCHAR
  2470. },
  2471. { "noauth", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_NOAUTHNOPRIV, 
  2472. dosnmp_group_authpriv_para,NULL,NULL, 0, 0, 
  2473. "noauth           --  Specifies no authentication of a packet",
  2474. "noauth           --  该组既不需要认证也不需要加密",
  2475.   NULLCHAR,NULLCHAR
  2476. },
  2477. { "priv", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_AUTHPRIV, 
  2478. dosnmp_group_authpriv_para,NULL,NULL, 0, 0, 
  2479. "priv             --  Specifies authentication of a packet with encryption",
  2480. "priv             --  该组需要认证和加密",
  2481.   NULLCHAR,NULLCHAR
  2482. },
  2484. { NULLCHAR }
  2485. };
  2487. #define SNMPV3_GROUP_SECURITY_V1    0x01
  2488. #define SNMPV3_GROUP_SECURITY_V2c   0x02
  2489. #define SNMPV3_GROUP_SECURITY_V3    0x04
  2491. static int dosnmp_group_security(int argc,char *argv[],struct user *u)
  2492. {
  2493.     if ((u->cmd_mskbits & SNMPV3_GROUP_SECURITY_V1) == 0)
  2494.     {
  2495.         u->struct_p[SNMPV3_GROUP_VER_INDEX] = SNMP_SEC_MODEL_SNMPv1;
  2496.     }
  2497.     else if ((u->cmd_mskbits & SNMPV3_GROUP_SECURITY_V2c) == 0)
  2498.     {
  2499.         u->struct_p[SNMPV3_GROUP_VER_INDEX] = SNMP_SEC_MODEL_SNMPv2c;
  2500.     }
  2501.     else if ((u->cmd_mskbits & SNMPV3_GROUP_SECURITY_V3) == 0)
  2502.     {
  2503.         u->struct_p[SNMPV3_GROUP_VER_INDEX] = SNMP_SEC_MODEL_USM;
  2504.     }
  2506.     u->cmd_mskbits = -1;
  2507.     if (u->struct_p[SNMPV3_GROUP_VER_INDEX] == SNMP_SEC_MODEL_USM)
  2508.     {
  2509.      return subcmd(snmp_group_authpriv_cmds, &u->cmd_mskbits, argc, argv, u);
  2510.     }
  2511.     else
  2512.     {
  2513.      return subcmd(snmp_group_view_access_cmds, &u->cmd_mskbits, argc, argv, u);
  2514.     }
  2515. }
  2517. static struct cmds snmp_group_cmds[] = {
  2518. { "v1", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_SECURITY_V1,
  2519. dosnmp_group_security,NULL,NULL, 0, 0, 
  2520. "v1               --  group using the v1 security model", 
  2521. "v1               --  该组使用SNMPv1安全模型", 
  2522.   NULLCHAR,NULLCHAR
  2523. },
  2524. { "v2c", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_SECURITY_V2c, 
  2525. dosnmp_group_security,NULL,NULL, 0, 0, 
  2526. "v2c              --  group using the v2c security model", 
  2527. "v2c              --  该组使用SNMPv2c安全模型", 
  2528.   NULLCHAR,NULLCHAR
  2529. },
  2530. { "v3", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_GROUP_SECURITY_V3, 
  2531. dosnmp_group_security,NULL,NULL, 0, 0, 
  2532. "v3               --  group using the User Security Model (SNMPv3)", 
  2533. "v3               --  该组使用基于用户的安全模型", 
  2534.   NULLCHAR,NULLCHAR
  2535. },
  2537. { NULLCHAR }
  2538. };
  2540. static int dosnmp_group(int argc,char *argv[],struct user *u)
  2541. {
  2542.     char *name;
  2543.     int rc;
  2545. switch(getstrrc(&name,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2546. case ARG_NOERR:
  2547.     break;
  2548.     case ARG_QUEST:
  2549.     case ARG_QUERY:
  2550.         eng_chi(u,  "  WORD    --  Name of the group",
  2551.                         "  WORD    --  组的名字");
  2552.         return 1;
  2553.      case ARG_PARAM :
  2554.      cmderror(ERR_NEXTP, NULL, u);
  2555.      return -1;
  2556.     case ARG_QPART:
  2557. case ARG_GENER:
  2558.     default:
  2559.      return -1;
  2560. }
  2562. memset((void *)u->struct_p, 0, sizeof(u->struct_p));
  2564.     u->cmd_mskbits = -1;
  2565. rc = subcmd(snmp_group_cmds, &u->cmd_mskbits, argc, argv, u);
  2566. if (rc != 0)
  2567.     return rc;
  2569.     if (IsNoPref(u)) {
  2570.         vacm_destroyAccessEntry(name, "", 
  2571.             u->struct_p[SNMPV3_GROUP_VER_INDEX], u->struct_p[SNMPV3_GROUP_AP_INDEX]);
  2572.         return 0;
  2573.     }
  2575. if (u->struct_p[SNMPV3_GROUP_READ_INDEX] == NULL)
  2576.     u->struct_p[SNMPV3_GROUP_READ_INDEX] = (int)SNMPV3_DEFAULT_VIEW;
  2578. vacm_parse_access_bdcom(name, u->struct_p[SNMPV3_GROUP_VER_INDEX], u->struct_p[SNMPV3_GROUP_AP_INDEX],
  2579.     (const char *)u->struct_p[SNMPV3_GROUP_READ_INDEX], (const char *)u->struct_p[SNMPV3_GROUP_WRITE_INDEX], (const char *)u->struct_p[SNMPV3_GROUP_NOTIFY_INDEX],
  2580.     (const char *)u->struct_p[SNMPV3_GROUP_ACL_INDEX]);
  2582. return 0;
  2583. }
  2585. /*show running group*/
  2586. static void display_a_group(struct vacm_accessEntry *group)
  2587. {
  2588.     vty_printf("snmp-server group %s ", &group->groupName[1]);
  2589.     switch(group->securityModel) {
  2590.     case SNMP_SEC_MODEL_SNMPv1:
  2591.         vty_printf("v1 ");
  2592.         break;
  2593.     case SNMP_SEC_MODEL_SNMPv2c:
  2594.         vty_printf("v2c ");
  2595.         break;
  2596.     case SNMP_SEC_MODEL_USM:
  2597.         vty_printf("v3 ");
  2598.         switch(group->securityLevel) {
  2599.         case SNMP_SEC_LEVEL_NOAUTH:
  2600.             vty_printf("noauth ");
  2601.             break;
  2602.         case SNMP_SEC_LEVEL_AUTHNOPRIV:
  2603.             vty_printf("auth ");
  2604.             break;
  2605.         case SNMP_SEC_LEVEL_AUTHPRIV:
  2606.             vty_printf("priv ");
  2607.             break;
  2608.         }
  2609.         break;
  2610.     }
  2612.     if (strcasecmp(group->readView, SNMPV3_DEFAULT_VIEW) != 0)
  2613.         vty_printf("read %s ", group->readView);
  2614.     if (group->writeView[0] != 0)
  2615.         vty_printf("write %s ", group->writeView);
  2616.     if (group->notifyView[0] != 0)
  2617.         vty_printf("notify %s ", group->notifyView);
  2618.     if (group->access_list[0] != 0)
  2619.         vty_printf("access %s", group->access_list);
  2621.     vty_printf("n");
  2622. }
  2624. static int display_snmp_group()
  2625. {
  2626.     return vacm_walkThrAccessEntry(display_a_group);
  2627. }
  2629. /*show commands*/
  2630. static void show_a_group(struct vacm_accessEntry *group)
  2631. {
  2632.     vty_printf("groupname: %sn", group->groupName);
  2633.     vty_printf("security model: ");
  2634.     switch(group->securityModel) {
  2635.     case SNMP_SEC_MODEL_SNMPv1:
  2636.         vty_printf("v1 ");
  2637.         break;
  2638.     case SNMP_SEC_MODEL_SNMPv2c:
  2639.         vty_printf("v2c ");
  2640.         break;
  2641.     case SNMP_SEC_MODEL_USM:
  2642.         vty_printf("v3 ");
  2643.         switch(group->securityLevel) {
  2644.         case SNMP_SEC_LEVEL_NOAUTH:
  2645.             vty_printf("noauth ");
  2646.             break;
  2647.         case SNMP_SEC_LEVEL_AUTHNOPRIV:
  2648.             vty_printf("auth ");
  2649.             break;
  2650.         case SNMP_SEC_LEVEL_AUTHPRIV:
  2651.             vty_printf("priv ");
  2652.             break;
  2653.         }
  2654.         break;
  2655.     }
  2656.     vty_printf("n");
  2658.     vty_printf("read: %s n", (strcasecmp(group->readView, SNMPV3_DEFAULT_VIEW) != 0) ?
  2659.         group->readView : "default");
  2660.     vty_printf("write: %s n", (strlen(group->writeView) != 0) ?
  2661.         group->writeView : "<no writeview specified>");
  2662.     vty_printf("notify: %s n", (strlen(group->notifyView) != 0) ?
  2663.         group->notifyView : "<no notifyview specified>");
  2664.     if (strlen(group->access_list) != 0)
  2665.         vty_printf("access list: %sn", group->access_list);
  2667.     vty_printf("n");
  2668. }
  2670. static int do_show_snmp_group(int argc,char *argv[],struct user *u)
  2671. {
  2672.     int rc;
  2673.     if ((rc = cmdend(--argc, ++argv, u)))
  2674.         return rc;
  2675.     vacm_walkThrAccessEntry(show_a_group);
  2676.     vty_printf_end(1);
  2677.     return 0;
  2678. }
  2680. /*
  2681.  *  snmpv3 user commands
  2682.  *  u->struct_p[0]: SNMP Security Modely, ie., SNMP version
  2683.  *  u->struct_p[1]: for version 3: authPriv or authNoPriv or NoAuthNoPriv;
  2684.  *                  for other version, not use
  2685.  *  u->struct_p[2]: remote flag
  2686.  *  u->struct_p[3]: remote host
  2687.  *  u->struct_p[4]: remote port
  2688.  *  u->struct_p[5]: auth digest method, md5 or sha
  2689.  *  u->struct_p[6]: auth password
  2690.  *  u->struct_p[7]: access list
  2691.  *  
  2692.  */
  2693. #define SNMPV3_USER_VER_INDEX 0
  2694. #define SNMPV3_USER_AP_INDEX 1
  2695. #define SNMPV3_USER_REMOTE_INDEX 2
  2696. #define SNMPV3_USER_REMOTE_HOST_INDEX 3
  2697. #define SNMPV3_USER_REMOTE_PORT_INDEX 4
  2698. #define SNMPV3_USER_AUTHMETHOD_INDEX 5
  2699. #define SNMPV3_USER_AUTHPSWD_INDEX 6
  2700. #define SNMPV3_USER_ACL_INDEX 7
  2703. static int dosnmp_user_authpriv_para(int argc,char *argv[],struct user *u);
  2705. #define SNMPV3_USER_AUTH        0x01
  2706. #define SNMPV3_USER_AUTH_MD5    0x02
  2707. #define SNMPV3_USER_AUTH_SHA    0x04
  2708. #define SNMPV3_USER_ENCRY       0x08
  2709. #define SNMPV3_USER_ACL         0x10
  2710. #define SNMPV3_USER_CR          0x80000000
  2712. #define SNMPV3_USER_SECURITY_V1    0x01
  2713. #define SNMPV3_USER_SECURITY_V2c   0x02
  2714. #define SNMPV3_USER_SECURITY_V3    0x04
  2715. #define SNMPV3_USER_REMOTE          0x08
  2716. #define SNMPV3_USER_REMOTE_PORT     0x10
  2718. static int dosnmp_user_auth(int argc, char *argv[],struct user *u);
  2719. static int dosnmp_user_encry(int argc, char *argv[],struct user *u);
  2720. static int dosnmp_user_acl(int argc,char *argv[],struct user *u)
  2721. {
  2722.     char *acl;
  2723.     int rc;
  2725. switch(getstrrc(&acl,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2726. case ARG_NOERR:
  2727.     break;
  2728.     case ARG_QUEST:
  2729.     case ARG_QUERY:
  2730.         eng_chi(u,  "  WORD    --  IP accesslist allowing access with this username",
  2731.                         "  WORD    --  该用户使用的IP访问列表");
  2732.         return 1;
  2733.      case ARG_PARAM :
  2734.      cmderror(ERR_NEXTP, NULL, u);
  2735.      return -1;
  2736.     case ARG_QPART:
  2737. case ARG_GENER:
  2738.     default:
  2739.      return -1;
  2740. }
  2742. if ((rc = cmdend(--argc, ++argv, u)))
  2743.     return rc;
  2745.     u->struct_p[SNMPV3_USER_ACL_INDEX] = (unsigned long)acl;
  2746. return 0;
  2747. }
  2749. static struct cmds snmp_user_authprivacl_cmds[] = {
  2750. { "auth", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_USER_AUTH,
  2751. dosnmp_user_auth,NULL,NULL, 0, 0, 
  2752. "auth             --  Specifies authentication parameters for the user",
  2753. "auth             --  设定用户的认证参数",
  2754.   NULLCHAR,NULLCHAR
  2755. },
  2756. { "md5", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_USER_AUTH_MD5, 
  2757. dosnmp_user_authpriv_para,NULL,NULL, 0, 0, 
  2758. "md5              --  Use HMAC MD5 algorithm for authentication",
  2759. "md5              --  使用MD5算法",
  2760.   NULLCHAR,NULLCHAR
  2761. },
  2762. { "sha", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_USER_AUTH_SHA,
  2763. dosnmp_user_authpriv_para,NULL,NULL, 0, 0, 
  2764. "sha              --  Use HMAC SHA algorithm for authentication",
  2765. "sha              --  使用SHA算法",
  2766.   NULLCHAR,NULLCHAR
  2767. },
  2768. { "encrypted", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_USER_ENCRY, 
  2769. dosnmp_user_encry,NULL,NULL, 0, 0, 
  2770. "encrypted        --  specifying passwords as MD5 or SHA digests",
  2771. "encrypted        --  用户的密码",
  2772.   NULLCHAR,NULLCHAR
  2773. },
  2774. { "access", MATCH_AMB, cmdPref(0, 0, 0), SNMPV3_USER_ACL, 
  2775. dosnmp_user_acl,NULL,NULL, 0, 0, 
  2776. "access           --  specify an access-list associated with this user",
  2777. "access           --  指定该用户的访问控制列表",
  2778.   NULLCHAR,NULLCHAR
  2779. },
  2781. { DUMMYSTR, MATCH_END, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_CR,
  2782. NULL,NULL,NULL, 0, 0, 
  2783. "<cr>",
  2784. "<cr>",
  2785.   NULLCHAR,NULLCHAR
  2786. },
  2788. { NULLCHAR }
  2789. };
  2790. static int dosnmp_user_auth(int argc, char *argv[],struct user *u)
  2791. {
  2792.     u->struct_p[SNMPV3_USER_AP_INDEX] |= SNMPV3_USER_AUTH;
  2793.     u->cmd_mskbits = SNMPV3_USER_AUTH_MD5|SNMPV3_USER_AUTH_SHA;
  2794.     return subcmd(snmp_user_authprivacl_cmds, &u->cmd_mskbits, argc, argv, u);
  2795. }
  2797. static int dosnmp_user_encry(int argc, char *argv[],struct user *u)
  2798. {
  2799.     u->struct_p[SNMPV3_USER_AP_INDEX] = SNMPV3_USER_ENCRY;
  2801.     /*encrypted命令后只能是auth命令*/
  2802.     u->cmd_mskbits = SNMPV3_USER_AUTH;
  2803.     return subcmd(snmp_user_authprivacl_cmds, &u->cmd_mskbits, argc, argv, u);
  2804. }
  2806. static int dosnmp_user_authpriv_para(int argc, char *argv[],struct user *u)
  2807. {
  2808.     char *password;
  2810.     if ((u->cmd_mskbits & SNMPV3_USER_AUTH_MD5) == 0)
  2811.         u->struct_p[SNMPV3_USER_AUTHMETHOD_INDEX] = SNMPV3_USER_AUTH_MD5;
  2812.     else
  2813.         u->struct_p[SNMPV3_USER_AUTHMETHOD_INDEX] = SNMPV3_USER_AUTH_SHA;
  2815. switch(getstrrc(&password,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2816. case ARG_NOERR:
  2817.     break;
  2818.     case ARG_QUEST:
  2819.     case ARG_QUERY:
  2820.         eng_chi(u,  "  WORD    --  authentication pasword for user",
  2821.                         "  WORD    --  用户的密码");
  2822.         return 1;
  2823.      case ARG_PARAM :
  2824.      cmderror(ERR_NEXTP, NULL, u);
  2825.      return -1;
  2826.     case ARG_QPART:
  2827. case ARG_GENER:
  2828.     default:
  2829.      return -1;
  2830. }
  2831. u->struct_p[SNMPV3_USER_AUTHPSWD_INDEX] = (unsigned long)password;
  2833.     if (argc > 1) {
  2834.         u->cmd_mskbits = SNMPV3_USER_ACL|SNMPV3_USER_CR;
  2835.         return subcmd(snmp_user_authprivacl_cmds, &u->cmd_mskbits, argc, argv, u);
  2836.     } else
  2837.         return 0;
  2838. }
  2840. static int dosnmp_user_security(int argc,char *argv[],struct user *u)
  2841. {
  2842.     if ((u->cmd_mskbits & SNMPV3_USER_SECURITY_V1) == 0)
  2843.     {
  2844.         u->struct_p[SNMPV3_USER_VER_INDEX] = SNMP_SEC_MODEL_SNMPv1;
  2845.     }
  2846.     else if ((u->cmd_mskbits & SNMPV3_USER_SECURITY_V2c) == 0)
  2847.     {
  2848.         u->struct_p[SNMPV3_USER_VER_INDEX] = SNMP_SEC_MODEL_SNMPv2c;
  2849.     }
  2850.     else if ((u->cmd_mskbits & SNMPV3_USER_SECURITY_V3) == 0)
  2851.     {
  2852.         u->struct_p[SNMPV3_USER_VER_INDEX] = SNMP_SEC_MODEL_USM;
  2853.     }
  2855.     if (u->struct_p[SNMPV3_USER_VER_INDEX] == SNMP_SEC_MODEL_USM)
  2856.     {
  2857.         u->cmd_mskbits = SNMPV3_USER_ENCRY|SNMPV3_USER_AUTH|SNMPV3_USER_ACL;
  2858.     }
  2859.     else
  2860.     {
  2861.         u->cmd_mskbits = SNMPV3_USER_ACL;
  2862.     }
  2864.     u->cmd_mskbits |= SNMPV3_USER_CR;
  2866.     if (argc > 1)
  2867.         return subcmd(snmp_user_authprivacl_cmds, &u->cmd_mskbits, argc, argv, u);
  2868.     else return 0;
  2869. }
  2871. static int dosnmp_user_remote_host(int argc,char *argv[],struct user *u);
  2872. static int dosnmp_user_remote_port(int argc,char *argv[],struct user *u);
  2874. static struct cmds snmp_user_version_remote_cmds[] = {
  2875. { "v1", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_SECURITY_V1,
  2876. dosnmp_user_security,NULL,NULL, 0, 0, 
  2877. "v1               --  user using the v1 security model",
  2878. "v1               --  该用户使用SNMPv1安全模型", 
  2879.   NULLCHAR,NULLCHAR
  2880. },
  2881. { "v2c", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_SECURITY_V2c, 
  2882. dosnmp_user_security,NULL,NULL, 0, 0, 
  2883. "v2c              --  user using the v2c security model",
  2884. "v2c              --  该用户使用SNMPv2c安全模型", 
  2885.   NULLCHAR,NULLCHAR
  2886. },
  2887. { "v3", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_SECURITY_V3, 
  2888. dosnmp_user_security,NULL,NULL, 0, 0, 
  2889. "v3               --  user using the v3 security model",
  2890. "v3               --  该用户使用基于用户的安全模型", 
  2891.   NULLCHAR,NULLCHAR
  2892. },
  2893. { "remote", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_REMOTE, 
  2894. dosnmp_user_remote_host,NULL,NULL, 0, 0, 
  2895. "remote           --  Specify a remote SNMP entity to which the user belongs",
  2896. "remote           --  指定该用户所属的远端SNMP实体",
  2897.   NULLCHAR,NULLCHAR
  2898. },
  2899. { "udp-port", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_USER_REMOTE_PORT,
  2900. dosnmp_user_remote_port,NULL,NULL, 0, 0, 
  2901. "udp-port         --  The remote SNMP entity's UDP port number",
  2902. "udp-port         --  远端SNMP实体的UDP端口号",
  2903.   NULLCHAR,NULLCHAR
  2904. },
  2906. { NULLCHAR }
  2907. };
  2909. static int dosnmp_user_remote_host(int argc,char *argv[],struct user *u)
  2910. {
  2911.     uint32 remoteaddr;
  2913. switch(getaddress((unsigned long *)&remoteaddr,  argc--, argv++, u)){
  2914. case ARG_NOERR:
  2915.     break;
  2916.     case ARG_QUEST:
  2917.     case ARG_QUERY:
  2918.         eng_chi(u,  "  A.B.C.D --  IP address of remote SNMP entity",
  2919.                         "  A.B.C.D --  远端SNMP实体的IP地址");
  2920.         return 1;
  2921.      case ARG_PARAM :
  2922.      cmderror(ERR_NEXTP, NULL, u);
  2923.      return -1;
  2924.     case ARG_QPART:
  2925. case ARG_GENER:
  2926.     default:
  2927.      return -1;
  2928. }
  2929. u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX] = remoteaddr;
  2931. u->cmd_mskbits |= SNMPV3_USER_REMOTE_PORT;
  2932. return subcmd(snmp_user_version_remote_cmds, &u->cmd_mskbits, argc, argv, u);
  2933. }
  2935. static int dosnmp_user_remote_port(int argc,char *argv[],struct user *u)
  2936. {
  2937.     uint32 remoteport;
  2939. switch(getuintrc((unsigned long *)&remoteport,  argc--, argv++, 0, 65535, u)){
  2940. case ARG_NOERR:
  2941.     break;
  2942.     case ARG_QUEST:
  2943.     case ARG_QUERY:
  2944.         eng_chi(u,  "  <0-65535> --  The remote SNMP entity's UDP port number",
  2945.                         "  <0-65535> --  远端SNMP实体的端口号");
  2946.         return 1;
  2947.      case ARG_PARAM :
  2948.      cmderror(ERR_NEXTP, NULL, u);
  2949.      return -1;
  2950.     case ARG_QPART:
  2951. case ARG_GENER:
  2952.     default:
  2953.      return -1;
  2954. }
  2955. u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX] = remoteport;
  2957. u->cmd_mskbits = ~(SNMPV3_USER_REMOTE_PORT|SNMPV3_USER_REMOTE);
  2958. return subcmd(snmp_user_version_remote_cmds, &u->cmd_mskbits, argc, argv, u);
  2959. }
  2961. static int dosnmp_user(int argc,char *argv[],struct user *u)
  2962. {
  2963.     char *username, *group;
  2964.     oid *privproto = usmNoPrivProtocol, *authproto = usmNoAuthProtocol;
  2965.     size_t privprotoLen = sizeof(usmNoPrivProtocol)/sizeof(oid),
  2966.            authprotoLen = sizeof(usmNoAuthProtocol)/sizeof(oid);
  2967.     char snmpEngineId[SNMP_MAX_ENG_SIZE], *pEid = NULL;
  2968.     size_t snmpEngineIdLen;
  2969.     int rc;
  2970.     struct usmUser *user;
  2972. switch(getstrrc(&username,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2973. case ARG_NOERR:
  2974.     break;
  2975.     case ARG_QUEST:
  2976.     case ARG_QUERY:
  2977.         eng_chi(u,  "  WORD    --  The name of the user on the host that connects to the agent",
  2978.                         "  WORD    --  用户的名字");
  2979.         return 1;
  2980.      case ARG_PARAM :
  2981.      cmderror(ERR_NEXTP, NULL, u);
  2982.      return -1;
  2983.     case ARG_QPART:
  2984. case ARG_GENER:
  2985.     default:
  2986.      return -1;
  2987. }
  2989. switch(getstrrc(&group,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  2990. case ARG_NOERR:
  2991.     break;
  2992.     case ARG_QUEST:
  2993.     case ARG_QUERY:
  2994.         eng_chi(u,  "  WORD    --  Group to which the user belongs",
  2995.                         "  WORD    --  用户的所属的组");
  2996.         return 1;
  2997.      case ARG_PARAM :
  2998.      cmderror(ERR_NEXTP, NULL, u);
  2999.      return -1;
  3000.     case ARG_QPART:
  3001. case ARG_GENER:
  3002.     default:
  3003.      return -1;
  3004. }
  3006. memset((void *)u->struct_p, 0, sizeof(u->struct_p));
  3008.     u->cmd_mskbits = ~SNMPV3_USER_REMOTE_PORT;
  3009. rc = subcmd(snmp_user_version_remote_cmds, &u->cmd_mskbits, argc, argv, u);
  3010. if (rc != 0)
  3011.     return rc;
  3013. if (u->struct_p[SNMPV3_USER_AP_INDEX] & SNMPV3_USER_ENCRY)
  3014. {
  3015.     privproto = usmDESPrivProtocol;
  3016.     privprotoLen = sizeof(usmDESPrivProtocol)/sizeof(oid);
  3017. }
  3018.     if (u->struct_p[SNMPV3_USER_AP_INDEX] & SNMPV3_USER_AUTH)
  3019.     {
  3020.         if (u->struct_p[SNMPV3_USER_AUTHMETHOD_INDEX] == SNMPV3_USER_AUTH_MD5)
  3021.         {
  3022.             authproto = usmHMACMD5AuthProtocol;
  3023.             authprotoLen = sizeof(usmHMACMD5AuthProtocol)/sizeof(oid);
  3024.         }
  3025.         else
  3026.         {
  3027.             authproto = usmHMACSHA1AuthProtocol;
  3028.             authprotoLen = sizeof(usmHMACSHA1AuthProtocol)/sizeof(oid);
  3029.         }
  3030.     }
  3032.     if (u->struct_p[SNMPV3_USER_ACL_INDEX] != 0) {
  3033.         if (strlen((char*)(u->struct_p[SNMPV3_USER_ACL_INDEX])) > sizeof(user->access_list)) {
  3034.             vty_output("%%Error: Access list too long.n");
  3035.             return 0;
  3036.         }
  3037.     }
  3039.     /*check if any duplicate snmp users ? */
  3040.     memset((void *)snmpEngineId, 0, sizeof(snmpEngineId));
  3041. if (u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX] != 0) {
  3042.     if (u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX] == 0)
  3043.         u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX] = SNMP_TRAP_PORT;
  3045.         pEid = snmpv3_get_remote_engineID(snmp_ntoa(u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX]),
  3046.                     u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX]);
  3047.         if (pEid == NULL && !IsNoPref(u)) {
  3048.             vty_output("%%Error: No snmpEngineID configured for remote snmp host %s port %d.n",
  3049.                         snmp_ntoa(u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX]), u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX]);
  3050.             return 0;
  3051.         }
  3052.         user = usm_get_user(pEid, SNMP_MAX_ENG_SIZE, username);
  3053.         if (user != NULL) {
  3054.             usm_remove_user(user);
  3055.             usm_free_user(user);
  3056.             snmpv3_dec_remote_engineID_reference(snmp_ntoa(u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX]),
  3057.                 u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX]);
  3058.         }
  3059.         snmpEngineIdLen = SNMP_MAX_ENG_SIZE;
  3060. } else {
  3061.         snmpEngineIdLen = snmpv3_get_engineID(snmpEngineId, sizeof(snmpEngineId));
  3062.         user = usm_get_user(snmpEngineId, snmpEngineIdLen, username);
  3063.         if (user != NULL) {
  3064.             usm_remove_user(user);
  3065.             usm_free_user(user);
  3066.         }
  3067. }
  3069. if (IsNoPref(u)) {
  3070.     vacm_destroyGroupEntry(u->struct_p[SNMPV3_USER_VER_INDEX], username);
  3071.     return 0;
  3072. }
  3074.     user = usm_parse_config_user_bdcom(username,
  3075.                 authproto, authprotoLen, privproto, privprotoLen, 
  3076.                (char *)( u->struct_p[SNMPV3_USER_AUTHPSWD_INDEX]),
  3077.                 pEid, snmpEngineIdLen);
  3079.     if (user == NULL)
  3080.         return 0;
  3082.     if (u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX] != 0) 
  3083.         snmpv3_inc_remote_engineID_reference(snmp_ntoa(u->struct_p[SNMPV3_USER_REMOTE_HOST_INDEX]),
  3084.             u->struct_p[SNMPV3_USER_REMOTE_PORT_INDEX]);
  3086.     usm_add_user(user);
  3087.     vacm_parse_group_bdcom(group, username, u->struct_p[SNMPV3_USER_VER_INDEX]);
  3089.     if (u->struct_p[SNMPV3_USER_ACL_INDEX] != 0) {
  3090.         strncpy(user->access_list, (char*)(u->struct_p[SNMPV3_USER_ACL_INDEX]),
  3091.             strlen((char *)(u->struct_p[SNMPV3_USER_ACL_INDEX])));
  3092.     } else
  3093.         user->access_list[0] = 0;
  3095.     return 0;
  3096. }
  3098. extern void snmpv3_get_remote_host_info_by_engineID(u_char *snmpEngineID, u_char **addr, u_short *port);
  3099. /*show running commands*/
  3100. static void display_a_user(struct usmUser *user)
  3101. {
  3102.     struct vacm_groupEntry *group;
  3103.     char *version_info, *auth_info = NULL, *encrypt_info = "", *remote_addr, l_snmpEngineID[SNMP_MAX_ENG_SIZE];
  3104.     u_short remote_port;
  3105.     size_t l_snmpeidLen;
  3107.     if (user->userStatus != RS_ACTIVE || user->userStorageType != ST_NONVOLATILE)
  3108.         return;
  3110.     vty_printf("snmp-server user %s ", user->name);
  3111.     if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_SNMPv1, user->secName)) != NULL) {
  3112.         version_info = "v1";
  3113.     } else if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_SNMPv2c, user->secName)) != NULL) {
  3114.         version_info = "v2c";
  3115.     } else if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_USM, user->secName)) != NULL) {
  3116.         version_info = "v3";
  3117.         if (snmp_oid_compare(user->privProtocol, user->privProtocolLen, 
  3118.                 usmDESPrivProtocol, sizeof(usmDESPrivProtocol)/sizeof(usmDESPrivProtocol[0])) == 0) {
  3119.             encrypt_info = "encrypted ";
  3120.         }
  3121.         if (snmp_oid_compare(user->authProtocol, user->authProtocolLen, 
  3122.                 usmHMACMD5AuthProtocol, sizeof(usmHMACMD5AuthProtocol)/sizeof(usmHMACMD5AuthProtocol[0])) == 0) {
  3123.             auth_info = "auth md5";
  3124.         } else if (snmp_oid_compare(user->authProtocol, user->authProtocolLen, 
  3125.                 usmHMACSHA1AuthProtocol, sizeof(usmHMACSHA1AuthProtocol)/sizeof(usmHMACSHA1AuthProtocol[0])) == 0) {
  3126.             auth_info = "auth sha";
  3127.         }
  3128.     }
  3130.     memset(l_snmpEngineID, 0, sizeof(l_snmpEngineID));
  3131.     /*l_snmpeidLen = snmpv3_get_engineID(&l_snmpEngineID, sizeof(l_snmpEngineID));*/
  3132.     l_snmpeidLen = snmpv3_get_engineID(l_snmpEngineID, sizeof(l_snmpEngineID));/*by yangyuhua 2005-12-6*/
  3133.     if (l_snmpeidLen == user->engineIDLen 
  3134.         && memcmp(l_snmpEngineID, user->engineID, l_snmpeidLen) == 0) {
  3135.         /*local user*/
  3136.         vty_printf("%s %s ", group->groupName, version_info);
  3137.     } else {
  3138.         snmpv3_get_remote_host_info_by_engineID(user->engineID, (u_char **)&remote_addr, &remote_port);
  3139.         if (remote_addr == NULL) {
  3140.             vty_printf("%s %s ", group->groupName, version_info);
  3141.         } else {
  3142.             vty_printf("%s remote %s ", group->groupName, remote_addr);
  3143.             if (remote_port != SNMP_TRAP_PORT)
  3144.                 vty_printf("udp-port %d ", remote_port);
  3145.             vty_printf("%s ", version_info);
  3146.         }
  3147.     }
  3149.     vty_printf("%s", encrypt_info);
  3150.     if (auth_info != NULL)
  3151.         vty_printf("%s %s", auth_info, user->password_plaintext);
  3153.     if (user->access_list[0] != 0)
  3154.         vty_printf("access %s", user->access_list);
  3156.     vty_printf("n");
  3157. }
  3159. static BOOL display_snmp_user()
  3160. {
  3161.     return usm_walkThrUserEntry(display_a_user);
  3162. }
  3164. /*show commands*/
  3165. static void show_a_user(struct usmUser *user)
  3166. {
  3167.     struct vacm_groupEntry *group;
  3168.     char engineID[SNMP_MAX_ENG_SIZE * 2 + 1];
  3170.     memset((void *)engineID, 0, sizeof(engineID));
  3171.     snmpv3_engineID2str(user->engineID, user->engineIDLen, engineID);
  3172.     vty_printf("User name: %sn", user->name);
  3173.     vty_printf("Engine ID: %sn", engineID);
  3174.     vty_printf("storage-type: ");
  3175.     switch (user->userStorageType) {
  3176.     case ST_OTHER:
  3177.         vty_printf("othern");
  3178.         break;
  3179.     case ST_VOLATILE:
  3180.         vty_printf("volatilen");
  3181.         break;
  3182.     case ST_NONVOLATILE:
  3183.         vty_printf("nonvolatilen");
  3184.         break;
  3185.     case ST_PERMANENT:
  3186.         vty_printf("permanentn");
  3187.         break;
  3188.     case ST_READONLY:
  3189.         vty_printf("readonlyn");
  3190.         break;
  3191.     default:
  3192.         vty_printf("unknownn");
  3193.     }
  3195.     vty_printf("Rowstatus: ");
  3196.     switch (user->userStatus) {
  3197.     case RS_ACTIVE:
  3198.         vty_printf("activen");
  3199.         break;
  3200.     case RS_NOTINSERVICE:
  3201.         vty_printf("notInServicen");
  3202.         break;
  3203.     case RS_NOTREADY:
  3204.         vty_printf("notReadyn");
  3205.         break;
  3206.     case RS_CREATEANDGO:
  3207.         vty_printf("createAndGon");
  3208.         break;
  3209.     case RS_CREATEANDWAIT:
  3210.         vty_printf("createAndWaitn");
  3211.         break;
  3212.     case RS_DESTROY:
  3213.         vty_printf("destroyn");
  3214.         break;
  3215.     default:
  3216.         vty_printf("unknownn");
  3217.     }
  3219.     vty_printf("Authentication Protocol: ");
  3220.     if (snmp_oid_compare(user->authProtocol, user->authProtocolLen, 
  3221.             usmHMACMD5AuthProtocol, sizeof(usmHMACMD5AuthProtocol)/sizeof(usmHMACMD5AuthProtocol[0])) == 0) {
  3222.         vty_printf("MD5 n");
  3223.     } else if (snmp_oid_compare(user->authProtocol, user->authProtocolLen, 
  3224.             usmHMACSHA1AuthProtocol, sizeof(usmHMACSHA1AuthProtocol)/sizeof(usmHMACSHA1AuthProtocol[0])) == 0) {
  3225.         vty_printf("SHA n");
  3226.     } else vty_printf("none n");
  3228.     vty_printf("Group-name: ");
  3229.     if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_SNMPv1, user->secName)) != NULL) {
  3230.         vty_printf("%st", group->groupName);
  3231.     } else if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_SNMPv2c, user->secName)) != NULL) {
  3232.         vty_printf("%st", group->groupName);
  3233.     } else if ((group = vacm_getGroupEntry(SNMP_SEC_MODEL_USM, user->secName)) != NULL) {
  3234.         vty_printf("%st", group->groupName);
  3235.     }
  3237.     if (user->access_list[0] != 0)
  3238.         vty_printf("access list: %s", user->access_list);
  3240.     vty_printf("nn");
  3241. }
  3243. static int do_show_snmp_user(int argc,char *argv[],struct user *u)
  3244. {
  3245.     int rc;
  3246.     if ((rc = cmdend(--argc, ++argv, u))){
  3247.         return rc;
  3248.     }
  3250.     usm_walkThrUserEntry(show_a_user);
  3251.     vty_printf_end(1);
  3252.     return 0;
  3253. }
  3255. /*
  3256.  * 下面两个全局变量用于传递参数.由于在调用其间保证不进行任务切换,因此不会导致同步错误
  3257.  */
  3258. static char *_oldEngineID, *_newEngineID;
  3259. static size_t _oldEidLen, _newEidLen;
  3260. static void refresh_a_snmp_user_engineID(struct usmUser *user)
  3261. {
  3262.     if (user->engineIDLen == _oldEidLen 
  3263.         && memcmp(user->engineID, _oldEngineID, _oldEidLen) == 0) {
  3264.         /*matched*/
  3265.         user->engineID = realloc(user->engineID, _newEidLen);
  3266.         memcpy(user->engineID, _newEngineID, _newEidLen);
  3267.         user->engineIDLen = _newEidLen;
  3268.     }
  3269. }
  3271. void refresh_snmp_user_engineID(char *oldID, size_t oldIDLen, char *newID, size_t newIDLen)
  3272. {
  3273.     _oldEngineID = oldID;
  3274.     _newEngineID = newID;
  3275.     _oldEidLen = oldIDLen;
  3276.     _newEidLen = newIDLen;
  3278.     usm_walkThrUserEntry(refresh_a_snmp_user_engineID);
  3280.     return;
  3281. }
  3283. /*
  3284.  *  snmpv3 engineid commands
  3285.  *  u->struct_p[0]: remote address
  3286.  *  u->struct_p[1]: remote port
  3287.  *  
  3288.  */
  3289. #define SNMPV3_ENGINEID_REMOTE_HOST_INDEX 0
  3290. #define SNMPV3_ENGINEID_REMOTE_PORT_INDEX 1
  3292. static int dosnmp_engineID_local(int argc,char *argv[],struct user *u);
  3293. static int dosnmp_engineID_remote(int argc,char *argv[],struct user *u);
  3294. static int dosnmp_engineID_string(int argc,char *argv[],struct user *u);
  3295. static int dosnmp_engineID_remote_udpport(int argc,char *argv[],struct user *u);
  3297. static struct cmds snmp_engineid_cmds[] = {
  3298. { "local", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0,
  3299. dosnmp_engineID_local,NULL,NULL, 0, 0, 
  3300. "local            --  engineID of the local agent",
  3301. "local            --  配置本地代理者的SNMP引擎ID", 
  3302.   NULLCHAR,NULLCHAR
  3303. },
  3304. { "remote", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), 0, 
  3305. dosnmp_engineID_remote,NULL,NULL, 0, 0, 
  3306. "remote           --  engineID of the remote agent",
  3307. "remote           --  配置远端代理者的SNMP引擎ID", 
  3308.   NULLCHAR,NULLCHAR
  3309. },
  3311. { NULLCHAR }
  3312. };
  3314. #define SNMPV3_ENGINEID_REMOTE_PORT     0x01
  3315. #define SNMPV3_ENGINEID_ENGINEID        0x02
  3317. static struct cmds snmp_engineid_string_cmds[] = {
  3318. { "WORD", MATCH_STR, cmdPref(PF_CMDNO, 0, 0), SNMPV3_ENGINEID_ENGINEID,
  3319. dosnmp_engineID_string,NULL,NULL, 0, 0, 
  3320. "WORD             --  engine ID octet string",
  3321. "WORD             --  SNMP引擎ID", 
  3322.   NULLCHAR,NULLCHAR
  3323. },
  3324. { "udp-port", MATCH_AMB, cmdPref(PF_CMDNO, 0, 0), SNMPV3_ENGINEID_REMOTE_PORT, 
  3325. dosnmp_engineID_remote_udpport,NULL,NULL, 0, 0, 
  3326. "udp-port         --  The remote notification host's UDP port number",
  3327. "udp-port         --  远端接收通知主机的UDP端口号", 
  3328.   NULLCHAR,NULLCHAR
  3329. },
  3331. { NULLCHAR }
  3332. };
  3334. static int dosnmp_engineID(int argc,char *argv[],struct user *u)
  3335. {
  3336.     memset((void *)u->struct_p, 0, sizeof(u->struct_p));
  3337.     return subcmd(snmp_engineid_cmds, &u->cmd_mskbits, argc, argv, u);
  3338. }
  3340. static int dosnmp_engineID_local(int argc,char *argv[],struct user *u)
  3341. {
  3342.     u->cmd_mskbits = SNMPV3_ENGINEID_ENGINEID;
  3343.     return subcmd(snmp_engineid_string_cmds, &u->cmd_mskbits, argc, argv, u);
  3344. }
  3346. static int dosnmp_engineID_remote(int argc,char *argv[],struct user *u)
  3347. {
  3348.     uint32 remoteaddr;
  3350. switch(getaddress((unsigned long *)&remoteaddr,  argc--, argv++, u)){
  3351. case ARG_NOERR:
  3352.     break;
  3353.     case ARG_QUEST:
  3354.     case ARG_QUERY:
  3355.         eng_chi(u,  "  A.B.C.D --  IP address of remote SNMP notification host",
  3356.                         "  A.B.C.D --  远端接收通知主机的IP地址");
  3357.         return 1;
  3358.      case ARG_PARAM :
  3359.      cmderror(ERR_NEXTP, NULL, u);
  3360.      return -1;
  3361.     case ARG_QPART:
  3362. case ARG_GENER:
  3363.     default:
  3364.      return -1;
  3365. }
  3367. u->struct_p[SNMPV3_ENGINEID_REMOTE_HOST_INDEX] = remoteaddr;
  3369. u->cmd_mskbits = SNMPV3_ENGINEID_ENGINEID|SNMPV3_ENGINEID_REMOTE_PORT;
  3370. return subcmd(snmp_engineid_string_cmds, &u->cmd_mskbits, argc, argv, u);
  3372. }
  3374. static int dosnmp_engineID_string(int argc,char *argv[],struct user *u)
  3375. {
  3376.     char *engineID_str, engineID[SNMP_MAX_ENG_SIZE], *peid = engineID, ipaddr[16];
  3377.     int rc;
  3379.     argc++;
  3380.     argv--;
  3381. switch(getstrrc(&engineID_str,  argc--, argv++, 0, SNMP_MAX_COMMUNITY_LEN, u)){
  3382. case ARG_NOERR:
  3383.     break;
  3384.     case ARG_QUEST:
  3385.     case ARG_QUERY:
  3386.         eng_chi(u,  "  WORD    --  engine ID octet string",
  3387.                         "  WORD    --  SNMP引擎ID");
  3388.         return 1;
  3389.      case ARG_PARAM :
  3390.      assert(0);
  3391.      return -1;
  3392.     case ARG_QPART:
  3393. case ARG_GENER:
  3394.     default:
  3395.      return -1;
  3396. }
  3398. rc = cmdend(--argc, ++argv, u);
  3399. if (rc)
  3400.     return rc;
  3402. /*convert engineID*/
  3403. memset((void *)engineID, 0, sizeof(engineID));
  3404. while (*engineID_str != 0) {
  3405.     int curbyte = 0, i;
  3406.     for(i=0;i<2;i++) {
  3407.          curbyte = curbyte << 4;
  3408.          if (isdigit(*engineID_str)) {
  3409.              curbyte += (int)((*engineID_str) - '0');
  3410.          } else if (*engineID_str >= 'a' && *engineID_str <= 'f') {
  3411.              curbyte += (int)((*engineID_str) - 'a' + 10);
  3412.          } else if (*engineID_str >= 'A' && *engineID_str <= 'F') {
  3413.              curbyte += (int)((*engineID_str) - 'A' + 10);
  3414.          } else {
  3415.              vty_output("%%Error: Invalid SNMP engine IDn");
  3416.              return -1;
  3417.          }
  3418.          engineID_str++;
  3419.     }
  3420.     *peid++ = curbyte;
  3421. }
  3423. if (u->struct_p[SNMPV3_ENGINEID_REMOTE_HOST_INDEX] != 0) {
  3424.     /*set remote engineID*/
  3425.     int ipaddr_n = ntohl(u->struct_p[SNMPV3_ENGINEID_REMOTE_HOST_INDEX]);
  3426.     ip2str((char*)&ipaddr_n, ipaddr);
  3427.     if (u->struct_p[SNMPV3_ENGINEID_REMOTE_PORT_INDEX] == 0)
  3428.         u->struct_p[SNMPV3_ENGINEID_REMOTE_PORT_INDEX] = SNMP_TRAP_PORT;
  3429.         if (IsNoPref(u))
  3430.          snmpv3_delete_remote_engineID(ipaddr,
  3431.              u->struct_p[SNMPV3_ENGINEID_REMOTE_PORT_INDEX]);
  3432.         else
  3433.          snmpv3_add_remote_engineID(ipaddr,
  3434.              u->struct_p[SNMPV3_ENGINEID_REMOTE_PORT_INDEX],
  3435.              engineID, SNMP_MAX_ENG_SIZE);
  3436. } else {
  3437.     /*set local engineID*/
  3438. }
  3439. return 0;
  3440. }
  3442. static int dosnmp_engineID_remote_udpport(int argc,char *argv[],struct user *u)
  3443. {
  3444.     uint32 remoteport;
  3446. switch(getuintrc((unsigned long *)&remoteport,  argc--, argv++, 0, 65535, u)){
  3447. case ARG_NOERR:
  3448.     break;
  3449.     case ARG_QUEST:
  3450.     case ARG_QUERY:
  3451.         eng_chi(u,  "  <0-65535> --  The remote notification host's UDP port number",
  3452.                         "  <0-65535> --  远端接收通知报文主机的端口号");
  3453.         return 1;
  3454.      case ARG_PARAM :
  3455.      cmderror(ERR_NEXTP, NULL, u);
  3456.      return -1;
  3457.     case ARG_QPART:
  3458. case ARG_GENER:
  3459.     default:
  3460.      return -1;
  3461. }
  3462. u->struct_p[SNMPV3_ENGINEID_REMOTE_PORT_INDEX] = remoteport;
  3463. return subcmd(snmp_engineid_string_cmds, &u->cmd_mskbits, argc, argv, u);
  3464. }
  3466. /*show commands*/
  3467. static int do_show_snmp_engineID(int argc,char *argv[],struct user *u)
  3468. {
  3469.     int rc;
  3471.     if ((rc = cmdend(--argc, ++argv, u)))
  3472.         return rc;
  3474.     do_show_snmpv3_remote_engineID();
  3475.     vty_printf_end(1);
  3476.     return 0;
  3477. }
  3479. #endif