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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > SNMP编程 > 查看源码
agent.xs
资源名称：net-snmp-5.2.2.rar　[点击查看]
上传用户：wxp200602
上传日期：2007-10-30
资源大小：4028k
文件大小：25k
源码类别：

SNMP编程

开发平台：

Unix_Linux

agent.xs：源码内容
  1. /* -*- C -*- */
  2. #include "EXTERN.h"
  3. #include "perl.h"
  4. #include "XSUB.h"
  5. #include <netdb.h>
  6. #include <sys/socket.h>
  8. #include <net-snmp/net-snmp-config.h>
  9. #include <net-snmp/net-snmp-includes.h>
  10. #include <net-snmp/agent/net-snmp-agent-includes.h>
  12. #ifndef sv_undef
  13. #define sv_undef PL_sv_undef
  14. #endif
  16. typedef struct handler_cb_data_s {
  17.    SV *perl_cb;
  18. } handler_cb_data;
  20. typedef struct netsnmp_oid_s {
  21.     unsigned int        *name;
  22.     unsigned int         len;
  23.     unsigned int         namebuf[ MAX_OID_LEN ];
  24. } netsnmp_oid;
  26. static int have_done_agent = 0;
  27. static int have_done_lib = 0;
  29. static int
  30. not_here(char *s)
  31. {
  32.     croak("%s not implemented on this architecture", s);
  33.     return -1;
  34. }
  36. static double
  37. constant_MODE_G(char *name, int len, int arg)
  38. {
  39.     if (6 + 2 > len ) {
  40. errno = EINVAL;
  41. return 0;
  42.     }
  43.     switch (name[6 + 2]) {
  44.     case '':
  45. if (strEQ(name + 6, "ET")) { /* MODE_G removed */
  46. #ifdef MODE_GET
  47.     return MODE_GET;
  48. #else
  49.     goto not_there;
  50. #endif
  51. }
  52.     case 'B':
  53. if (strEQ(name + 6, "ETBULK")) { /* MODE_G removed */
  54. #ifdef MODE_GETBULK
  55.     return MODE_GETBULK;
  56. #else
  57.     goto not_there;
  58. #endif
  59. }
  60.     case 'N':
  61. if (strEQ(name + 6, "ETNEXT")) { /* MODE_G removed */
  62. #ifdef MODE_GETNEXT
  63.     return MODE_GETNEXT;
  64. #else
  65.     goto not_there;
  66. #endif
  67. }
  68.     }
  69.     errno = EINVAL;
  70.     return 0;
  72. not_there:
  73.     errno = ENOENT;
  74.     return 0;
  75. }
  77. static double
  78. constant_MODE_SET_R(char *name, int len, int arg)
  79. {
  80.     if (10 + 6 >= len ) {
  81. errno = EINVAL;
  82. return 0;
  83.     }
  84.     switch (name[10 + 6]) {
  85.     case '1':
  86. if (strEQ(name + 10, "ESERVE1")) { /* MODE_SET_R removed */
  87. #ifdef MODE_SET_RESERVE1
  88.     return MODE_SET_RESERVE1;
  89. #else
  90.     goto not_there;
  91. #endif
  92. }
  93.     case '2':
  94. if (strEQ(name + 10, "ESERVE2")) { /* MODE_SET_R removed */
  95. #ifdef MODE_SET_RESERVE2
  96.     return MODE_SET_RESERVE2;
  97. #else
  98.     goto not_there;
  99. #endif
  100. }
  101.     }
  102.     errno = EINVAL;
  103.     return 0;
  105. not_there:
  106.     errno = ENOENT;
  107.     return 0;
  108. }
  110. static double
  111. constant_SNMP_ERR(char *name, int len, int arg)
  112. {
  113.     if (9 + 1 >= len ) {
  114. errno = EINVAL;
  115. return 0;
  116.     }
  117.     switch (name[9]) {
  119.     case 'A':
  120. if (strEQ(name + 10, "UTHORIZATIONERROR")) { /* SNMP_ERR_A removed */
  121. #ifdef SNMP_ERR_AUTHORIZATIONERROR
  122.     return SNMP_ERR_AUTHORIZATIONERROR;
  123. #else
  124.     goto not_there;
  125. #endif
  126. }
  127.         break;
  129.     case 'B':
  130. if (strEQ(name + 10, "ADVALUE")) { /* SNMP_ERR_B removed */
  131. #ifdef SNMP_ERR_BADVALUE
  132.     return SNMP_ERR_BADVALUE;
  133. #else
  134.     goto not_there;
  135. #endif
  136. }
  137.         break;
  139.     case 'C':
  140. if (strEQ(name + 10, "OMMITFAILED")) { /* SNMP_ERR_C removed */
  141. #ifdef SNMP_ERR_COMMITFAILED
  142.     return SNMP_ERR_COMMITFAILED;
  143. #else
  144.     goto not_there;
  145. #endif
  146. }
  147.         break;
  149.     case 'G':
  150. if (strEQ(name + 10, "ENERR")) { /* SNMP_ERR_G removed */
  151. #ifdef SNMP_ERR_GENERR
  152.     return SNMP_ERR_GENERR;
  153. #else
  154.     goto not_there;
  155. #endif
  156. }
  157.         break;
  159.     case 'I':
  160. if (strEQ(name + 10, "NCONSISTENTVALUE")) { /* SNMP_ERR_I removed */
  161. #ifdef SNMP_ERR_INCONSISTENTVALUE
  162.     return SNMP_ERR_INCONSISTENTVALUE;
  163. #else
  164.     goto not_there;
  165. #endif
  166. }
  167.         break;
  169.     case 'N':
  170. if (strEQ(name + 10, "OACCESS")) { /* SNMP_ERR_N removed */
  171. #ifdef SNMP_ERR_NOACCESS
  172.     return SNMP_ERR_NOACCESS;
  173. #else
  174.     goto not_there;
  175. #endif
  176. }
  178. if (strEQ(name + 10, "OCREATION")) { /* SNMP_ERR_N removed */
  179. #ifdef SNMP_ERR_NOCREATION
  180.     return SNMP_ERR_NOCREATION;
  181. #else
  182.     goto not_there;
  183. #endif
  184. }
  186. if (strEQ(name + 10, "OERROR")) { /* SNMP_ERR_N removed */
  187. #ifdef SNMP_ERR_NOERROR
  188.     return SNMP_ERR_NOERROR;
  189. #else
  190.     goto not_there;
  191. #endif
  192. }
  194. if (strEQ(name + 10, "OSUCHNAME")) { /* SNMP_ERR_N removed */
  195. #ifdef SNMP_ERR_NOSUCHNAME
  196.     return SNMP_ERR_NOSUCHNAME;
  197. #else
  198.     goto not_there;
  199. #endif
  200. }
  202. if (strEQ(name + 10, "OTWRITABLE")) { /* SNMP_ERR_N removed */
  203. #ifdef SNMP_ERR_NOTWRITABLE
  204.     return SNMP_ERR_NOTWRITABLE;
  205. #else
  206.     goto not_there;
  207. #endif
  208. }
  209.         break;
  211.     case 'R':
  212. if (strEQ(name + 10, "EADONLY")) { /* SNMP_ERR_R removed */
  213. #ifdef SNMP_ERR_READONLY
  214.     return SNMP_ERR_READONLY;
  215. #else
  216.     goto not_there;
  217. #endif
  218. }
  220. if (strEQ(name + 10, "ESOURCEUNAVAILABLE")) { /* SNMP_ERR_R removed */
  221. #ifdef SNMP_ERR_RESOURCEUNAVAILABLE
  222.     return SNMP_ERR_RESOURCEUNAVAILABLE;
  223. #else
  224.     goto not_there;
  225. #endif
  226. }
  227.         break;
  229.     case 'T':
  230. if (strEQ(name + 10, "OOBIG")) { /* SNMP_ERR_T removed */
  231. #ifdef SNMP_ERR_TOOBIG
  232.     return SNMP_ERR_TOOBIG;
  233. #else
  234.     goto not_there;
  235. #endif
  236. }
  237.         break;
  239.     case 'U':
  240. if (strEQ(name + 10, "NDOFAILED")) { /* SNMP_ERR_U removed */
  241. #ifdef SNMP_ERR_UNDOFAILED
  242.     return SNMP_ERR_UNDOFAILED;
  243. #else
  244.     goto not_there;
  245. #endif
  246. }
  247.         break;
  249.     case 'W':
  250. if (strEQ(name + 10, "RONGENCODING")) { /* SNMP_ERR_W removed */
  251. #ifdef SNMP_ERR_WRONGENCODING
  252.     return SNMP_ERR_WRONGENCODING;
  253. #else
  254.     goto not_there;
  255. #endif
  256. }
  258. if (strEQ(name + 10, "RONGLENGTH")) { /* SNMP_ERR_W removed */
  259. #ifdef SNMP_ERR_WRONGLENGTH
  260.     return SNMP_ERR_WRONGLENGTH;
  261. #else
  262.     goto not_there;
  263. #endif
  264. }
  266. if (strEQ(name + 10, "RONGTYPE")) { /* SNMP_ERR_W removed */
  267. #ifdef SNMP_ERR_WRONGTYPE
  268.     return SNMP_ERR_WRONGTYPE;
  269. #else
  270.     goto not_there;
  271. #endif
  272. }
  274. if (strEQ(name + 10, "RONGVALUE")) { /* SNMP_ERR_W removed */
  275. #ifdef SNMP_ERR_WRONGVALUE
  276.     return SNMP_ERR_WRONGVALUE;
  277. #else
  278.     goto not_there;
  279. #endif
  280. }
  281.     }
  282. not_there:
  283.     errno = ENOENT;
  284.     return 0;
  285. }
  286.     
  287. static double
  288. constant_MODE_S(char *name, int len, int arg)
  289. {
  290.     if (6 + 3 >= len ) {
  291. errno = EINVAL;
  292. return 0;
  293.     }
  294.     switch (name[6 + 3]) {
  295.     case 'A':
  296. if (strEQ(name + 6, "ET_ACTION")) { /* MODE_S removed */
  297. #ifdef MODE_SET_ACTION
  298.     return MODE_SET_ACTION;
  299. #else
  300.     goto not_there;
  301. #endif
  302. }
  303.     case 'B':
  304. if (strEQ(name + 6, "ET_BEGIN")) { /* MODE_S removed */
  305. #ifdef MODE_SET_BEGIN
  306.     return MODE_SET_BEGIN;
  307. #else
  308.     goto not_there;
  309. #endif
  310. }
  311.     case 'C':
  312. if (strEQ(name + 6, "ET_COMMIT")) { /* MODE_S removed */
  313. #ifdef MODE_SET_COMMIT
  314.     return MODE_SET_COMMIT;
  315. #else
  316.     goto not_there;
  317. #endif
  318. }
  319.     case 'F':
  320. if (strEQ(name + 6, "ET_FREE")) { /* MODE_S removed */
  321. #ifdef MODE_SET_FREE
  322.     return MODE_SET_FREE;
  323. #else
  324.     goto not_there;
  325. #endif
  326. }
  327.     case 'R':
  328. if (!strnEQ(name + 6,"ET_", 3))
  329.     break;
  330. return constant_MODE_SET_R(name, len, arg);
  331.     case 'U':
  332. if (strEQ(name + 6, "ET_UNDO")) { /* MODE_S removed */
  333. #ifdef MODE_SET_UNDO
  334.     return MODE_SET_UNDO;
  335. #else
  336.     goto not_there;
  337. #endif
  338. }
  339.     }
  340.     errno = EINVAL;
  341.     return 0;
  343. not_there:
  344.     errno = ENOENT;
  345.     return 0;
  346. }
  348. static double
  349. constant(char *name, int len, int arg)
  350. {
  351.     errno = 0;
  352.     if (0 + 5 >= len ) {
  353. errno = EINVAL;
  354. return 0;
  355.     }
  356.     switch (name[0 + 5]) {
  357.     case 'G':
  358. if (!strnEQ(name + 0,"MODE_", 5))
  359.     break;
  360. return constant_MODE_G(name, len, arg);
  361.     case 'S':
  362. if (!strnEQ(name + 0,"MODE_", 5))
  363.     break;
  364. return constant_MODE_S(name, len, arg);
  365.     case 'E':
  366. if (!strnEQ(name + 0,"SNMP_ERR_", 9))
  367.     break;
  368. return constant_SNMP_ERR(name, len, arg);
  369.     }
  370.     errno = EINVAL;
  371.     return 0;
  373. not_there:
  374.     errno = ENOENT;
  375.     return 0;
  376. }
  378. int
  379. handler_wrapper(netsnmp_mib_handler          *handler,
  380.                 netsnmp_handler_registration *reginfo,
  381.                 netsnmp_agent_request_info   *reqinfo,
  382.                 netsnmp_request_info         *requests) 
  383. {
  384.     u_long intret = 5;
  385.     handler_cb_data *cb_data = (handler_cb_data *) handler->myvoid;
  386.     SV *cb;
  388.     if (cb_data && (cb = cb_data->perl_cb)) {
  389.         SV *arg;
  390.         SV *rarg;
  391.         dSP;
  392.         ENTER;
  393.         SAVETMPS;
  394.         PUSHMARK(sp);
  395.         rarg = newSViv(0);
  396.         arg = newSVrv(rarg, "NetSNMP::agent::netsnmp_mib_handler");
  397.         sv_setiv(arg, (int) handler);
  398.         XPUSHs(sv_2mortal(rarg));
  399.         rarg = newSViv(0);
  400.         arg = newSVrv(rarg, "NetSNMP::agent::reginfo");
  401.         sv_setiv(arg, (int) reginfo);
  402.         XPUSHs(sv_2mortal(rarg));
  403.         rarg = newSViv(0);
  404.         arg = newSVrv(rarg, "NetSNMP::agent::netsnmp_agent_request_info");
  405.         sv_setiv(arg, (int) reqinfo);
  406.         XPUSHs(sv_2mortal(rarg));
  407.         rarg = newSViv(0);
  408.         arg = newSVrv(rarg, "NetSNMP::agent::netsnmp_request_infoPtr");
  409.         sv_setiv(arg, (int) requests);
  410.         XPUSHs(sv_2mortal(rarg));
  411.         PUTBACK;
  412.         if (SvTYPE(cb) == SVt_PVCV) {
  413.             perl_call_sv(cb, G_DISCARD);
  414.                                        
  415.         } else if (SvROK(cb) && SvTYPE(SvRV(cb)) == SVt_PVCV) {
  416.             perl_call_sv(SvRV(cb), G_DISCARD); 
  417.         }
  418.         SPAGAIN;
  419.         PUTBACK;
  420.         FREETMPS;
  421.         LEAVE;
  422.     }
  423.     return SNMP_ERR_NOERROR;
  424. }
  426. MODULE = NetSNMP::agent PACKAGE = NetSNMP::agent
  428. double
  429. constant(sv,arg)
  430.     PREINIT:
  431. STRLEN len;
  432.     INPUT:
  433. SV * sv
  434. char * s = SvPV(sv, len);
  435. int arg
  436.     CODE:
  437. RETVAL = constant(s,len,arg);
  438.     OUTPUT:
  439. RETVAL
  441. int
  442. __agent_check_and_process(block = 1)
  443. int block;
  444.     CODE:
  445. RETVAL = agent_check_and_process(block);
  446.     OUTPUT:
  447. RETVAL
  449. void
  450. init_mib()
  452. int
  453. init_agent(name)
  454.         const char *name;
  456. void
  457. init_snmp(name)
  458.         const char *name;
  460. int
  461. init_master_agent()
  463. void    
  464. snmp_enable_stderrlog()    
  466. MODULE = NetSNMP::agent  PACKAGE = NetSNMP::agent PREFIX = na_
  468. void
  469. na_shutdown(me)
  470.     SV *me;
  471.     CODE:
  472.     {
  473.         snmp_shutdown("perl");
  474.     }
  476. void
  477. na_errlog(me,value)
  478.     SV *me;
  479.     SV *value;
  480.    PREINIT:
  481.         STRLEN stringlen;
  482.         char * stringptr;
  483.     CODE:
  484.     {
  485.         stringptr = SvPV(value, stringlen);
  486.         snmp_log(LOG_ERR, stringptr );
  487.     }
  491. MODULE = NetSNMP::agent  PACKAGE = NetSNMP::agent::netsnmp_handler_registration  PREFIX = nsahr_
  493. netsnmp_handler_registration *
  494. nsahr_new(name, regoid, perlcallback)
  495.         char *name;
  496. char *regoid;
  497.         SV   *perlcallback;
  498.     PREINIT:
  499. oid myoid[MAX_OID_LEN];
  500. size_t myoid_len = MAX_OID_LEN;
  501.         handler_cb_data *cb_data;
  502.         int gotit=1;
  503.     CODE:
  504. if (!snmp_parse_oid(regoid, myoid, &myoid_len)) {
  505.             if (!read_objid(regoid, myoid, &myoid_len)) {
  506.                 snmp_log(LOG_ERR, "couldn't parse %s (reg name: %s)n",
  507.                         regoid, name);
  508.                 RETVAL = NULL;
  509.                 gotit = 0;
  510.             }
  511.         }
  512.         if (gotit) {
  513.             cb_data = (handler_cb_data *) malloc(sizeof(handler_cb_data));
  514.             RETVAL = netsnmp_create_handler_registration(name, handler_wrapper,
  515.                                                  myoid, myoid_len,
  516.                                                  HANDLER_CAN_RWRITE);
  517.             cb_data->perl_cb = newSVsv(perlcallback);
  518.             RETVAL->handler->myvoid = cb_data;
  519.         }
  520.     OUTPUT:
  521.         RETVAL
  523. MODULE = NetSNMP::agent  PACKAGE = netsnmp_handler_registrationPtr  PREFIX = nsahr_
  525. void
  526. nsahr_DESTROY(reginfo)
  527. netsnmp_handler_registration *reginfo
  528.     CODE:
  529. netsnmp_handler_registration_free(reginfo);
  531. int
  532. nsahr_register(me)
  533.         SV *me;
  534.         PREINIT:
  535.         netsnmp_handler_registration *reginfo;
  536.         CODE:
  537.             {
  538.                 reginfo = (netsnmp_handler_registration *) SvIV(SvRV(me));
  539.                 RETVAL = netsnmp_register_handler(reginfo);
  540.                 if (!RETVAL) {
  541.                     /* the agent now has a "reference" to this reg pointer */
  542.                     SvREFCNT_inc(me);
  543.                 }
  544.             }
  545.     OUTPUT:
  546. RETVAL
  548. void
  549. nsahr_getRootOID(me)
  550.     SV *me;
  551.     PREINIT:
  552.         int i;
  553.         netsnmp_oid *o;
  554.         netsnmp_handler_registration *reginfo;
  555.         SV *arg, *rarg;
  556.     PPCODE:
  557.     {
  558.         dSP;
  559.         PUSHMARK(SP);
  560.         reginfo = (netsnmp_handler_registration *) SvIV(SvRV(me));
  562.         o = SNMP_MALLOC_TYPEDEF(netsnmp_oid);
  563.         o->name = o->namebuf;
  564.         o->len = reginfo->rootoid_len;
  565.         memcpy(o->name, reginfo->rootoid,
  566.                reginfo->rootoid_len * sizeof(oid));
  568.         rarg = newSViv((int) 0);
  569.         arg = newSVrv(rarg, "netsnmp_oidPtr");
  570.         sv_setiv(arg, (int) o);
  572.         XPUSHs(rarg);
  574.         PUTBACK;
  575.         i = perl_call_pv("NetSNMP::OID::newwithptr", G_SCALAR);
  576.         SPAGAIN;
  577.         if (i != 1) {
  578.             snmp_log(LOG_ERR, "unhandled OID error.n");
  579.             /* ack XXX */
  580.         }
  581.         ST(0) = POPs;
  582.         XSRETURN(1);
  583.     }
  585. MODULE = NetSNMP::agent  PACKAGE = NetSNMP::agent::netsnmp_request_infoPtr PREFIX = nari_
  587. void
  588. getOID(me)
  589.     SV *me;
  590.     PREINIT:
  591.         int i;
  592.         netsnmp_oid *o;
  593.         netsnmp_request_info *request;
  594.         SV *arg, *rarg;
  595.     PPCODE:
  596.     {
  597.         dSP;
  598.         PUSHMARK(SP);
  599.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  601.         o = SNMP_MALLOC_TYPEDEF(netsnmp_oid);
  602.         o->name = o->namebuf;
  603.         o->len = request->requestvb->name_length;
  604.         memcpy(o->name, request->requestvb->name,
  605.                request->requestvb->name_length * sizeof(oid));
  607.         rarg = newSViv((int) 0);
  608.         arg = newSVrv(rarg, "netsnmp_oidPtr");
  609.         sv_setiv(arg, (int) o);
  611.         XPUSHs(rarg);
  613.         PUTBACK;
  614.         i = perl_call_pv("NetSNMP::OID::newwithptr", G_SCALAR);
  615.         SPAGAIN;
  616.         if (i != 1) {
  617.             snmp_log(LOG_ERR, "unhandled OID error.n");
  618.             /* ack XXX */
  619.         }
  620.         ST(0) = POPs;
  621.         XSRETURN(1);
  622.     }
  623.         
  624. netsnmp_oid *
  625. nari_getOIDptr(me)
  626.         SV *me;
  627.         PREINIT:
  628.         netsnmp_request_info *request;
  629.         CODE:
  630.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  631.         RETVAL = SNMP_MALLOC_TYPEDEF(netsnmp_oid);
  632.         RETVAL->name = RETVAL->namebuf;
  633.         RETVAL->len = request->requestvb->name_length;
  634.         memcpy(RETVAL->name, request->requestvb->name,
  635.                request->requestvb->name_length * sizeof(oid));
  636.     OUTPUT:
  637.         RETVAL
  639. int
  640. nari_getType(me)
  641.         SV *me;
  642.     PREINIT:
  643.         netsnmp_request_info *request;
  644.     CODE:
  645.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  647.         RETVAL =  request->requestvb->type ;
  648.     OUTPUT:
  649.         RETVAL 
  651. void
  652. nari_setType(me, newvalue)
  653.         SV *me;
  654.         int newvalue;
  655.     PREINIT:
  656.         netsnmp_request_info *request;
  657.     CODE:
  658.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  659.         request->requestvb->type=newvalue;
  661. char *
  662. nari_getValue(me)
  663.         SV *me;
  664.     PREINIT:
  665.         u_char buf[1024] ;
  666.         u_char *oidbuf = buf ;
  667.         size_t ob_len = 1024, oo_len = 0;
  668.         netsnmp_request_info *request;
  669.     CODE:
  670.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  671. sprint_realloc_by_type(&oidbuf, &ob_len, &oo_len, 0,
  672.                                request->requestvb, 0, 0, 0);
  673.         RETVAL = oidbuf; /* mem leak */
  674.     OUTPUT:
  675.         RETVAL
  677. int
  678. nari_getDelegated(me)
  679.         SV *me;
  680.     PREINIT:
  681.         netsnmp_request_info *request;
  682.     CODE:
  683.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  684.         RETVAL = request->delegated;
  685.     OUTPUT:
  686.         RETVAL
  688. void
  689. nari_setDelegated(me, newdelegated)
  690.         SV *me;
  691.         int newdelegated;
  692.     PREINIT:
  693.         netsnmp_request_info *request;
  694.     CODE:
  695.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  696.         request->delegated = newdelegated;
  698. int
  699. nari_getProcessed(me)
  700.         SV *me;
  701.     PREINIT:
  702.         netsnmp_request_info *request;
  703.     CODE:
  704.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  705.         RETVAL = request->processed;
  706.     OUTPUT:
  707.         RETVAL
  709. void
  710. nari_setProcessed(me, newprocessed)
  711.         SV *me;
  712.         int newprocessed;
  713.     PREINIT:
  714.         netsnmp_request_info *request;
  715.     CODE:
  716.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  717.         request->processed = newprocessed;
  719. int
  720. nari_getStatus(me)
  721.         SV *me;
  722.     PREINIT:
  723.         netsnmp_request_info *request;
  724.     CODE:
  725.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  726.         RETVAL = request->status;
  727.     OUTPUT:
  728.         RETVAL
  730. void
  731. nari_setStatus(me, newstatus)
  732.         SV *me;
  733.         int newstatus;
  734.     PREINIT:
  735.         netsnmp_request_info *request;
  736.     CODE:
  737.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  738.         request->status = newstatus;
  740. int
  741. nari_getRepeat(me)
  742.         SV *me;
  743.     PREINIT:
  744.         netsnmp_request_info *request;
  745.     CODE:
  746.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  747.         RETVAL = request->repeat;
  748.     OUTPUT:
  749.         RETVAL
  751. void
  752. nari_setRepeat(me, newrepeat)
  753.         SV *me;
  754.         int newrepeat;
  755.     PREINIT:
  756.         netsnmp_request_info *request;
  757.     CODE:
  758.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  759.         request->repeat = newrepeat;
  761. int
  762. nari_setValue(me, type, value)
  763.         SV *me;
  764.         int type;
  765.         SV *value;
  766.     PREINIT:
  767.         u_char *oidbuf = NULL;
  768.         size_t ob_len = 0, oo_len = 0;
  769.         netsnmp_request_info *request;
  770.         u_long utmp;
  771.         long ltmp;
  772. oid myoid[MAX_OID_LEN];
  773. size_t myoid_len;
  774.         STRLEN stringlen;
  775.         char * stringptr;
  776.     CODE:
  777.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  778.         switch(type) {
  779.           case  SNMP_NOSUCHINSTANCE :
  780.               snmp_set_var_typed_value(request->requestvb,SNMP_NOSUCHINSTANCE,0,0) ;
  781.               RETVAL = 1;
  782.               break ;
  783.           case  SNMP_NOSUCHOBJECT :
  784.               snmp_set_var_typed_value(request->requestvb,SNMP_NOSUCHOBJECT,0,0) ;
  785.               RETVAL = 1;
  786.               break ;
  787.           case  SNMP_ENDOFMIBVIEW :
  788.               snmp_set_var_typed_value(request->requestvb,SNMP_ENDOFMIBVIEW,0,0) ;
  789.               RETVAL = 1;
  790.               break ;
  791.           case ASN_INTEGER:
  792.       /* We want an integer here */
  793.       if ((SvTYPE(value) == SVt_IV) || (SvTYPE(value) == SVt_PVMG)) {
  794.   /* Good - got a real one (or a blessed object that we hope will turn out OK) */
  795.   ltmp = SvIV(value);
  796.   snmp_set_var_typed_value(request->requestvb, (u_char)type,
  797.    (u_char *) &ltmp, sizeof(ltmp));
  798.   RETVAL = 1;
  799.   break;
  800.       }
  801.       else if (SvPOKp(value)) {
  802.           /* Might be OK - got a string, so try to convert it, allowing base 10, octal, and hex forms */
  803.           stringptr = SvPV(value, stringlen);
  804.   ltmp = strtol( stringptr, NULL, 0 );
  805.   if (errno == EINVAL) {
  806.    snmp_log(LOG_ERR, "Could not convert string to number in setValue: '%s'", stringptr);
  807. RETVAL = 0;
  808. break;
  809.   }
  811.   snmp_set_var_typed_value(request->requestvb, (u_char)type,
  812.    (u_char *) &ltmp, sizeof(ltmp));
  813.   RETVAL = 1;
  814.   break;
  815.       }
  816.       else {
  817. snmp_log(LOG_ERR, "Non-integer value passed to setValue with ASN_INTEGER: type was %dn",
  818. SvTYPE(value));
  819. RETVAL = 0;
  820. break;
  821.       }
  824.           case ASN_UNSIGNED:
  825.           case ASN_COUNTER:
  826.           case ASN_COUNTER64:
  827.           case ASN_TIMETICKS:
  828.       /* We want an integer here */
  829.       if ((SvTYPE(value) == SVt_IV) || (SvTYPE(value) == SVt_PVMG)) {
  830.   /* Good - got a real one (or a blessed scalar which we have to hope will turn out OK) */
  831.   utmp = SvIV(value);
  832.                   snmp_set_var_typed_value(request->requestvb, (u_char)type,
  833.                                        (u_char *) &utmp, sizeof(utmp));
  834.   RETVAL = 1;
  835.   break;
  836.       }
  837.       else if (SvPOKp(value)) {
  838.           /* Might be OK - got a string, so try to convert it, allowing base 10, octal, and hex forms */
  839.           stringptr = SvPV(value, stringlen);
  840.   utmp = strtoul( stringptr, NULL, 0 );
  841.   if (errno == EINVAL) {
  842.    snmp_log(LOG_ERR, "Could not convert string to number in setValue: '%s'", stringptr);
  843. RETVAL = 0;
  844. break;
  845.   }
  847.                   snmp_set_var_typed_value(request->requestvb, (u_char)type,
  848.                                        (u_char *) &utmp, sizeof(utmp));
  849.   RETVAL = 1;
  850.   break;
  851.       }
  852.       else {
  853. snmp_log(LOG_ERR, "Non-unsigned-integer value passed to setValue with ASN_UNSIGNED/ASN_COUNTER/ASN_TIMETICKS: type was %dn",
  854. SvTYPE(value));
  855. RETVAL = 0;
  856. break;
  857.       }
  859.           case ASN_OCTET_STR:
  860.           case ASN_BIT_STR:
  861.       /* Check that we have been passed something with a string value (or a blessed scalar) */
  862.       if (!SvPOKp(value) && (SvTYPE(value) != SVt_PVMG)) {
  863. snmp_log(LOG_ERR, "Non-string value passed to setValue with ASN_OCTET_STR/ASN_BIT_STR: type was %dn",
  864. SvTYPE(value));
  865. RETVAL = 0;
  866. break;
  867.       }
  869.       /* Find length of string (strlen will *not* do, as these are binary strings) */
  870.       stringptr = SvPV(value, stringlen);
  872.               snmp_set_var_typed_value(request->requestvb, (u_char)type,
  873.                                        (u_char *) stringptr,
  874.                                        stringlen);
  875.               RETVAL = 1;
  876.               break;
  878.           case ASN_IPADDRESS:
  879.       /* IP addresses are passed as *binary* strings.
  880.        * In the case of IPv4 addresses, these are 4 bytes long.
  881.        * NOTE: the use of binary strings rather than dotted-quad or FQDNs was
  882.        * introduced here by Andrew Findlay's patch of March 17th 2003,
  883.        * and is effectively a change to the previous implied API which assumed
  884.        * the value was a (valid) hostname.
  885.        * Responsibility for decoding and resolving has been passed up to the Perl script.
  886.        */
  888.       /* Check that we have been passed something with a string value (or a blessed scalar) */
  889.       if (!SvPOKp(value) && (SvTYPE(value) != SVt_PVMG)) {
  890. snmp_log(LOG_ERR, "Non-string value passed to setValue with ASN_IPADDRESS: type was %dn",
  891. SvTYPE(value));
  892. RETVAL = 0;
  893. break;
  894.       }
  896.       /* Find length of string (strlen will *not* do, as these are binary strings) */
  897.       stringptr = SvPV(value, stringlen);
  899.       # snmp_log(LOG_ERR, "IP address returned with length %d: %u.%u.%u.%un", stringlen, stringptr[0],
  900.       #     stringptr[1], stringptr[2], stringptr[3] );
  902.       # Sanity check on address length
  903.       if ((stringlen != 4) && (stringlen != 16)) {
  904.        snmp_log(LOG_ERR, "IP address of %d bytes passed to setValue with ASN_IPADDRESSn", stringlen);
  905. RETVAL = 0;
  906. break;
  907.       }
  909.               snmp_set_var_typed_value(request->requestvb, (u_char)type,
  910.                                    stringptr, stringlen);
  911.               RETVAL = 1;
  912.               break;
  914.           case ASN_OBJECT_ID:
  915.       /* Check that we have been passed something with a string value (or a blessed scalar) */
  916.       if (!SvPOKp(value) && (SvTYPE(value) != SVt_PVMG)) {
  917. snmp_log(LOG_ERR, "Non-string value passed to setValue with ASN_OBJECT_ID: type was %dn",
  918. SvTYPE(value));
  919. RETVAL = 0;
  920. break;
  921.       }
  923.       /* Extract the string */
  924.       stringptr = SvPV(value, stringlen);
  926.       /* snmp_log(LOG_ERR, "setValue returning OID '%s'n", stringptr); */
  928.       myoid_len = MAX_OID_LEN;
  929.               if (!snmp_parse_oid(stringptr, myoid, &myoid_len)) {
  930.                   snmp_log(LOG_ERR, "couldn't parse %s in setValuen", stringptr);
  931.   RETVAL = 0;
  932.   break;
  933.               } else {
  934.   /* snmp_log(LOG_ERR, "setValue returning OID length %dn", myoid_len); */
  936.                   request = (netsnmp_request_info *) SvIV(SvRV(me));
  937.                   snmp_set_var_typed_value(request->requestvb, (u_char)type,
  938.                                            (u_char *) myoid, (myoid_len * sizeof(myoid[0])) );
  939.               }
  941.               RETVAL = 1;
  942.               break;
  943.               
  944.             default:
  945.                 snmp_log(LOG_ERR, "unknown var value type: %dn",
  946.                         type);
  947.                 RETVAL = 0;
  948.                 break;
  949.         }
  951.     OUTPUT:
  952.         RETVAL
  953.         
  954. void
  955. nari_setOID(me, value)
  956.         SV *me;
  957.         char *value;
  958.     PREINIT:
  959. oid myoid[MAX_OID_LEN];
  960. size_t myoid_len = MAX_OID_LEN;
  961.         netsnmp_request_info *request;
  962.     CODE:
  963. myoid_len = MAX_OID_LEN;
  964. if (!snmp_parse_oid(value, myoid, &myoid_len)) {
  965.             snmp_log(LOG_ERR, "couldn't parse %s in setOIDn", value);
  966.         } else {
  967.             request = (netsnmp_request_info *) SvIV(SvRV(me));
  968.             snmp_set_var_objid(request->requestvb, myoid, myoid_len);
  969.         }
  971. void
  972. nari_setError(me, rinfo, ecode)
  973.         SV *me;
  974.         SV *rinfo;
  975.         int ecode;
  976.     PREINIT:
  977. oid myoid[MAX_OID_LEN];
  978. size_t myoid_len = MAX_OID_LEN;
  979.         netsnmp_request_info *request;
  980.         netsnmp_agent_request_info *reqinfo;
  981.     CODE:
  982.         request = (netsnmp_request_info *) SvIV(SvRV(me));
  983.         reqinfo = (netsnmp_agent_request_info *) SvIV(SvRV(rinfo));
  984.         netsnmp_set_request_error(reqinfo, request, ecode);
  986. SV *
  987. nari_next(me)
  988.         SV *me;
  989.     PREINIT:
  990.         netsnmp_request_info *request;
  991.         SV *arg, *rarg;
  992.     CODE:
  993.         {
  994.             request = (netsnmp_request_info *) SvIV(SvRV(me));
  995.             if (request && request->next) {
  996.                 request = request->next;
  997.                 rarg = newSViv(0);
  998.                 arg = newSVrv(rarg, "NetSNMP::agent::netsnmp_request_infoPtr");
  999.                 sv_setiv(arg, (int) request);
  1000.                 ST(0) = rarg;
  1001.             } else {
  1002.                 ST(0) = &sv_undef;
  1003.             }
  1004.         }
  1006. MODULE = NetSNMP::agent  PACKAGE = NetSNMP::agent::netsnmp_agent_request_info PREFIX = narqi_
  1008. int
  1009. narqi_getMode(me)
  1010.         SV *me;
  1011.     PREINIT:
  1012.         netsnmp_agent_request_info *reqinfo;
  1013.     CODE:
  1014.         reqinfo = (netsnmp_agent_request_info *) SvIV(SvRV(me));
  1015.         RETVAL = reqinfo->mode;
  1016.     OUTPUT:
  1017.         RETVAL
  1019. void
  1020. narqi_setMode(me, newvalue)
  1021.         SV *me;
  1022.         int newvalue;
  1023.     PREINIT:
  1024.         netsnmp_agent_request_info *reqinfo;
  1025.     CODE:
  1026.         reqinfo = (netsnmp_agent_request_info *) SvIV(SvRV(me));
  1027.         reqinfo->mode = newvalue;
  1028.         
  1030. MODULE = NetSNMP::agent PACKAGE = NetSNMP::agent