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

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

SNMP编程

开发平台：

C/C++

vacm.c：源码内容
  1. /*
  2.  * vacm.c
  3.  *
  4.  * SNMPv3 View-based Access Control Model
  5.  */
  7. #include <config.h>
  9. #if HAVE_STDLIB_H
  10. #include <stdlib.h>
  11. #endif
  12. #if HAVE_STRING_H
  13. #include <string.h>
  14. #else
  15. #include <strings.h>
  16. #endif
  17. #if HAVE_UNISTD_H
  18. #include <unistd.h>
  19. #endif
  20. #include <sys/types.h>
  21. #include <stdio.h>
  22. #if TIME_WITH_SYS_TIME
  23. # ifdef WIN32
  24. #  include <sys/timeb.h>
  25. # else
  26. #  include <time.h>
  27. # endif
  28. # include <time.h>
  29. #else
  30. # if HAVE_SYS_TIME_H
  31. #  include <sys/time.h>
  32. # else
  33. #  include <time.h>
  34. # endif
  35. #endif
  37. #if HAVE_WINSOCK_H
  38. #include <ip/socket.h>
  39. #endif
  41. #if HAVE_NETINET_IN_H
  42. #include <netinet/in.h>
  43. #endif
  45. #if HAVE_DMALLOC_H
  46. #include <dmalloc.h>
  47. #endif
  49. #include "asn1.h"
  50. #include "snmp.h"
  51. #include "snmp_api.h"
  52. #include "vacm.h"
  53. #include "snmp_debug.h"
  55. static struct vacm_viewEntry *viewList = NULL, *viewScanPtr = NULL;
  56. static struct vacm_accessEntry *accessList = NULL, *accessScanPtr = NULL;
  57. static struct vacm_groupEntry *groupList = NULL, *groupScanPtr = NULL;
  59. struct vacm_viewEntry *
  60. vacm_getViewEntry(const char *viewName,
  61.   oid *viewSubtree,
  62.   size_t viewSubtreeLen)
  63. {
  64.     struct vacm_viewEntry *vp, *vpret = NULL;
  65.     char view[VACMSTRINGLEN];
  66.     int found, glen;
  68.     glen = (int)strlen(viewName);
  69.     if (glen < 0 || glen >= VACM_MAX_STRING)
  70.         return NULL;
  71.     view[0] = (u_char)glen;
  72.     strcpy(view+1, viewName);
  73.     for(vp = viewList; vp; vp = vp->next){
  74.         if (!memcmp(view, vp->viewName,glen+1)
  75.     && viewSubtreeLen >= vp->viewSubtreeLen) {
  76.     int mask = 0x80, maskpos = 0;
  77.     int oidpos;
  78.             found = 1;
  79.     for (oidpos = 0; found && oidpos < (int)vp->viewSubtreeLen; oidpos++) {
  80. if ((vp->viewMask[maskpos] & mask) != 0) {
  81.     if (viewSubtree[oidpos] != vp->viewSubtree[oidpos])
  82.                         found = 0;
  83. }
  84. if (mask == 1) {
  85.     mask = 0x80;
  86.     maskpos++;
  87. }
  88. else mask >>= 1;
  89.     }
  90.             if (found) {
  91.               /* match successful, keep this node if its longer than
  92.                  the previous or (equal and lexicographically greater
  93.                  than the previous). */
  94.               if (vpret == NULL || vp->viewSubtreeLen > vpret->viewSubtreeLen ||
  95.                   (vp->viewSubtreeLen == vpret->viewSubtreeLen &&
  96.                    snmp_oid_compare(vp->viewSubtree, vp->viewSubtreeLen,
  97.                                     vpret->viewSubtree,
  98.                                     vpret->viewSubtreeLen) > 0))
  99.                 vpret = vp;
  100.             }
  101. }
  102.     }
  103.     DEBUGMSGTL(("vacm:getView", ", %s", (vpret)?"found":"none"));
  104.     return vpret;
  105. }
  107. void
  108. vacm_scanViewInit (void)
  109. {
  110.     viewScanPtr = viewList;
  111. }
  113. struct vacm_viewEntry *
  114. vacm_scanViewNext (void)
  115. {
  116.     struct vacm_viewEntry *returnval = viewScanPtr;
  117.     if (viewScanPtr) viewScanPtr = viewScanPtr->next;
  118.     return returnval;
  119. }
  120. struct vacm_viewEntry *
  121. vacm_createViewEntry(const char *viewName,
  122.      oid *viewSubtree,
  123.      size_t viewSubtreeLen)
  124. {
  125.     struct vacm_viewEntry *vp, *lp, *op = NULL;
  126.     int cmp, glen;
  128.     glen = (int)strlen(viewName);
  129.     if (glen < 0 || glen >= VACM_MAX_STRING)
  130.         return NULL;
  131.     vp = (struct vacm_viewEntry *)calloc(1, sizeof(struct vacm_viewEntry));
  132.     if (vp == NULL)
  133.         return NULL;
  134.     vp->reserved = (struct vacm_viewEntry *)calloc(1, sizeof(struct vacm_viewEntry));
  135.     if (vp->reserved == NULL) {
  136.         free(vp);
  137.         return NULL;
  138.     }
  140.     vp->viewName[0] = (u_char)glen;
  141.     strcpy(vp->viewName+1, viewName);
  142.     memcpy(vp->viewSubtree, viewSubtree, viewSubtreeLen * sizeof(oid));
  143.     vp->viewSubtreeLen = viewSubtreeLen;
  144. vp->viewStatus = SNMP_ROW_NOTINSERVICE;
  145. vp->viewStorageType = SNMP_STORAGE_NONVOLATILE;
  146. vp->viewType = 1;
  148.     lp = viewList;
  149.     while (lp) {
  150. cmp = memcmp(lp->viewName, vp->viewName, glen+1);
  151. if (cmp > 0) break;
  152. if (cmp < 0) goto next;
  154. next:
  155. op = lp;
  156. lp = lp->next;
  157.     }
  158.     vp->next = lp;
  159.     if (op) op->next = vp;
  160.     else viewList = vp;
  161.     return vp;
  162. }
  163. struct vacm_viewEntry *
  164. vacm_findViewEntryByName (const char *viewName)
  165. {
  166.     struct vacm_viewEntry *vp;
  167.     char view[VACMSTRINGLEN];
  168. int glen;
  170.     glen = (int)strlen(viewName);
  171.     if (glen < 0 || glen >= VACM_MAX_STRING)
  172.         return NULL;
  173.     view[0] = (u_char)glen;
  174.     strcpy(view+1, viewName);
  176. for (vp = viewList; vp; vp = vp->next)
  177. {
  178. if (!memcmp(view, vp->viewName,glen+1))
  179. return vp;
  180. }
  181. return NULL;
  183. }
  185. BOOL vacm_walkThrViewEntry (void (*thrMethod)(struct vacm_viewEntry*))
  186. {
  187. struct vacm_viewEntry *vp;
  189. if (viewList == NULL)
  190. return FALSE;
  191. for (vp = viewList; vp != NULL; vp = vp->next)
  192. {
  193. if (strstr (vp->viewName, "__vn") == NULL)
  194. thrMethod (vp);
  195. }
  196. return TRUE;
  197. }
  199. void
  200. vacm_destroyViewEntry(const char *viewName,
  201.       oid *viewSubtree,
  202.       size_t viewSubtreeLen)
  203. {
  204.     struct vacm_viewEntry *vp, *lastvp = NULL;
  206.     if (viewList && !strcmp(viewList->viewName+1, viewName)
  207. && viewList->viewSubtreeLen == viewSubtreeLen
  208. && !memcmp((char *)viewList->viewSubtree, (char *)viewSubtree,
  209.  viewSubtreeLen * sizeof(oid))){
  210. vp = viewList;
  211. viewList = viewList->next;
  212.     } else {
  213. for (vp = viewList; vp; vp = vp->next){
  214.     if (!strcmp(vp->viewName+1, viewName)
  215. && vp->viewSubtreeLen  == viewSubtreeLen 
  216. && !memcmp((char *)vp->viewSubtree, (char *)viewSubtree,
  217.  viewSubtreeLen * sizeof(oid)))
  218. break;
  219.     lastvp = vp;
  220. }
  221. if (!vp)
  222.     return;
  223. lastvp->next = vp->next;
  224.     }
  225.     if (vp->reserved)
  226. free(vp->reserved);
  227.     free(vp);
  228.     return;
  229. }
  231. void vacm_destroyAllViewEntries (void)
  232. {
  233.     struct vacm_viewEntry *vp;
  234.     while ((vp = viewList)) {
  235. viewList = vp->next;
  236. if (vp->reserved) free(vp->reserved);
  237. free(vp);
  238.     }
  239. }
  241. struct vacm_groupEntry *
  242. vacm_getGroupEntry(int securityModel,
  243.    const char *securityName)
  244. {
  245.     struct vacm_groupEntry *vp;
  246.     char secname[VACMSTRINGLEN];
  247.     int glen;
  249.     glen = (int)strlen(securityName);
  250.     if (glen < 0 || glen >= VACM_MAX_STRING)
  251.         return NULL;
  252.     secname[0] = (u_char)glen;
  253.     strcpy(secname+1, securityName);
  255.     for (vp = groupList; vp; vp = vp->next) {
  256. if ((securityModel == vp->securityModel || vp->securityModel == SNMP_SEC_MODEL_ANY)
  257.     && !memcmp(vp->securityName, secname,glen+1))
  258. return vp;
  259.     }
  260.     return NULL;
  261. }
  263. void
  264. vacm_scanGroupInit (void)
  265. {
  266.     groupScanPtr = groupList;
  267. }
  269. struct vacm_groupEntry *
  270. vacm_scanGroupNext (void)
  271. {
  272.     struct vacm_groupEntry *returnval = groupScanPtr;
  273.     if (groupScanPtr) groupScanPtr = groupScanPtr->next;
  274.     return returnval;
  275. }
  277. struct vacm_groupEntry *
  278. vacm_createGroupEntry(int securityModel,
  279.       const char *securityName)
  280. {
  281.     struct vacm_groupEntry *gp, *lg, *og;
  282.     int cmp, glen;
  284.     glen = (int)strlen(securityName);
  285.     if (glen < 0 || glen >= VACM_MAX_STRING)
  286.         return NULL;
  287.     gp = (struct vacm_groupEntry *)calloc(1, sizeof(struct vacm_groupEntry));
  288.     if (gp == NULL)
  289.         return NULL;
  290.     gp->reserved = (struct vacm_groupEntry *)calloc(1, sizeof(struct vacm_groupEntry));
  291.     if (gp->reserved == NULL) {
  292.         free(gp);
  293.         return NULL;
  294.     }
  296.     gp->securityModel = securityModel;
  297.     gp->securityName[0] = (u_char)glen;
  298. gp->status = SNMP_ROW_NOTREADY;
  299. gp->storageType = SNMP_STORAGE_OTHER;
  300.     strcpy(gp->securityName+1, securityName);
  302.     lg = groupList;
  303.     og = NULL;
  304.     while (lg) {
  305. if (lg->securityModel > securityModel) break;
  306. if (lg->securityModel == securityModel && 
  307.     (cmp = memcmp(lg->securityName, gp->securityName, glen+1)) > 0) break;
  308. /* if (lg->securityModel == securityModel && cmp == 0) abort(); */
  309. og = lg; lg = lg->next;
  310.     }
  311.     gp->next = lg;
  312.     if (og == NULL) groupList = gp;
  313.     else og->next = gp;
  314.     return gp;
  315. }
  317. void
  318. vacm_destroyGroupEntry(int securityModel,
  319.        const char *securityName)
  320. {
  321.     struct vacm_groupEntry *vp, *lastvp = NULL;
  323.     if (groupList && groupList->securityModel == securityModel
  324. && !strcmp(groupList->securityName+1, securityName)) {
  325. vp = groupList;
  326. groupList = groupList->next;
  327.     } else {
  328. for (vp = groupList; vp; vp = vp->next){
  329.     if (vp->securityModel == securityModel
  330. && !strcmp(vp->securityName+1, securityName))
  331. break;
  332.     lastvp = vp;
  333. }
  334. if (!vp)
  335.     return;
  336. lastvp->next = vp->next;
  337.     }
  338.     if (vp->reserved)
  339. free(vp->reserved);
  340.     free(vp);
  341.     return;
  342. }
  344. void vacm_destroyAllGroupEntries (void)
  345. {
  346.     struct vacm_groupEntry *gp;
  347.     while ((gp = groupList)) {
  348. groupList = gp->next;
  349. if (gp->reserved) free(gp->reserved);
  350. free(gp);
  351.     }
  352. }
  354. BOOL vacm_walkThrAccessEntry (void (*thrMethod)(struct vacm_accessEntry*))
  355. {
  356. struct vacm_accessEntry *va;
  358. if (accessList == NULL)
  359. return FALSE;
  360. for (va = accessList; va != NULL; va = va->next)
  361. {
  362. if (strstr (va->groupName, "__gn") == NULL)
  363.      thrMethod (va);
  364. }
  365. return TRUE;
  366. }
  368. struct vacm_accessEntry *
  369. vacm_getAccessEntry(const char *groupName, 
  370.     const char *contextPrefix,
  371.     int securityModel, 
  372.     int securityLevel)
  373. {
  374.     struct vacm_accessEntry *vp;
  375.     char group[VACMSTRINGLEN];
  376.     char context[VACMSTRINGLEN];
  377.     int glen, clen;
  379.     glen = (int)strlen(groupName);
  380.     if (glen < 0 || glen >= VACM_MAX_STRING)
  381.         return NULL;
  382.     clen = (int)strlen(contextPrefix);
  383.     if (clen < 0 || clen >= VACM_MAX_STRING)
  384.         return NULL;
  386.     group[0] = (u_char)glen;
  387.     strcpy(group+1, groupName);
  388.     context[0] = (u_char)clen;
  389.     strcpy(context+1, contextPrefix);
  390.     for(vp = accessList; vp; vp = vp->next){
  391.         if ((securityModel == vp->securityModel || vp->securityModel == SNMP_SEC_MODEL_ANY)
  392.     && securityLevel >= vp->securityLevel
  393.     && !memcmp(vp->groupName, group, glen+1)
  394.     && !memcmp(vp->contextPrefix, context, clen+1))
  395.   return vp;
  396.     }
  397.     return NULL;
  398. }
  400. void
  401. vacm_scanAccessInit (void)
  402. {
  403.     accessScanPtr = accessList;
  404. }
  406. struct vacm_accessEntry *
  407. vacm_scanAccessNext (void)
  408. {
  409.     struct vacm_accessEntry *returnval = accessScanPtr;
  410.     if (accessScanPtr) accessScanPtr = accessScanPtr->next;
  411.     return returnval;
  412. }
  414. struct vacm_accessEntry *
  415. vacm_createAccessEntry(const char *groupName, 
  416.        const char *contextPrefix,
  417.        int securityModel, 
  418.        int securityLevel)
  419. {
  420.     struct vacm_accessEntry *vp, *lp, *op = NULL;
  421.     int cmp, glen, clen;
  423.     glen = (int)strlen(groupName);
  424.     if (glen < 0 || glen >= VACM_MAX_STRING)
  425.         return NULL;
  426.     clen = (int)strlen(contextPrefix);
  427.     if (clen < 0 || clen >= VACM_MAX_STRING)
  428.         return NULL;
  429.     vp = (struct vacm_accessEntry *)calloc(1, sizeof(struct vacm_accessEntry));
  430.     if (vp == NULL)
  431.         return NULL;
  432.     vp->reserved = (struct vacm_accessEntry *)calloc(1, sizeof(struct vacm_accessEntry));
  433.     if (vp->reserved == NULL) {
  434.         free(vp);
  435.         return NULL;
  436.     }
  438.     vp->securityModel = securityModel;
  439.     vp->securityLevel = securityLevel;
  440.     vp->groupName[0] = (u_char)glen;
  441.     strcpy(vp->groupName+1, groupName);
  442.     vp->contextPrefix[0] = (u_char)clen;
  443.     strcpy(vp->contextPrefix+1, contextPrefix);
  444. vp->status = SNMP_ROW_NOTREADY;
  445. vp->storageType = SNMP_STORAGE_OTHER;
  447.     lp = accessList;
  448.     while (lp) {
  449. cmp = memcmp(lp->groupName, vp->groupName, glen+1);
  450. if (cmp > 0) break;
  451. if (cmp < 0) goto next;
  452. cmp = memcmp(lp->contextPrefix, vp->contextPrefix, clen+1);
  453. if (cmp > 0) break;
  454. if (cmp < 0) goto next;
  455. if (lp->securityModel > securityModel) break;
  456. if (lp->securityModel < securityModel) goto next;
  457. if (lp->securityLevel > securityLevel) break;
  458. next:
  459. op = lp;
  460. lp = lp->next;
  461.     }
  462.     vp->next = lp;
  463.     if (op == NULL) accessList = vp;
  464.     else op->next = vp;
  465.     return vp;
  466. }
  468. void
  469. vacm_destroyAccessEntry(const char *groupName, 
  470. const char *contextPrefix,
  471. int securityModel,
  472. int securityLevel)
  473. {
  474.     struct vacm_accessEntry *vp, *lastvp = NULL;
  476.     if (accessList && accessList->securityModel == securityModel
  477. && accessList->securityModel == securityModel
  478. && !strcmp(accessList->groupName+1, groupName)
  479. && !strcmp(accessList->contextPrefix+1, contextPrefix)) {
  480. vp = accessList;
  481. accessList = accessList->next;
  482.     } else {
  483. for (vp = accessList; vp; vp = vp->next){
  484.     if (vp->securityModel == securityModel
  485. && vp->securityLevel == securityLevel
  486. && !strcmp(vp->groupName+1, groupName)
  487. && !strcmp(vp->contextPrefix+1, contextPrefix))
  488. break;
  489.     lastvp = vp;
  490. }
  491. if (!vp)
  492.     return;
  493. lastvp->next = vp->next;
  494.     }
  495.     if (vp->reserved)
  496. free(vp->reserved);
  497.     free(vp);
  498.     return;
  499. }
  501. void vacm_destroyAllAccessEntries (void)
  502. {
  503.     struct vacm_accessEntry *ap;
  504.     while ((ap = accessList)) {
  505. accessList = ap->next;
  506. if (ap->reserved) free(ap->reserved);
  507. free(ap);
  508.     }
  509. }
  511. /* returns 1 if vacm has *any* configuration entries in it (regardless
  512.    of weather or not there is enough to make a decision based on it),
  513.    else return 0 */
  514. int vacm_is_configured(void) {
  515.     if (viewList == NULL && accessList == NULL && groupList == NULL)
  516.         return 0;
  517.     return 1;
  518. }