PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/snmp - snmp.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 33 427 7.7 %
Date: 2014-07-13 Functions: 4 36 11.1 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 The PHP Group                                |
       6             :    +----------------------------------------------------------------------+
       7             :    | This source file is subject to version 3.01 of the PHP license,      |
       8             :    | that is bundled with this package in the file LICENSE, and is        |
       9             :    | available through the world-wide-web at the following url:           |
      10             :    | http://www.php.net/license/3_01.txt                                  |
      11             :    | If you did not receive a copy of the PHP license and are unable to   |
      12             :    | obtain it through the world-wide-web, please send a note to          |
      13             :    | license@php.net so we can mail you a copy immediately.               |
      14             :    +----------------------------------------------------------------------+
      15             :    | Authors: Rasmus Lerdorf <rasmus@php.net>                             |
      16             :    |          Mike Jackson <mhjack@tscnet.com>                            |
      17             :    |          Steven Lawrance <slawrance@technologist.com>                |
      18             :    |          Harrie Hazewinkel <harrie@lisanza.net>                      |
      19             :    |          Johann Hanne <jonny@nurfuerspam.de>                         |
      20             :    +----------------------------------------------------------------------+
      21             :  */
      22             : 
      23             : /* $Id$ */
      24             : 
      25             : #ifdef HAVE_CONFIG_H
      26             : #include "config.h"
      27             : #endif
      28             : 
      29             : #include "php.h"
      30             : #include "ext/standard/info.h"
      31             : #include "php_snmp.h"
      32             : 
      33             : #if HAVE_SNMP
      34             : 
      35             : #include <sys/types.h>
      36             : #ifdef PHP_WIN32
      37             : #include <winsock2.h>
      38             : #include <errno.h>
      39             : #include <process.h>
      40             : #include "win32/time.h"
      41             : #elif defined(NETWARE)
      42             : #ifdef USE_WINSOCK
      43             : #include <novsock2.h>
      44             : #else
      45             : #include <sys/socket.h>
      46             : #endif
      47             : #include <errno.h>
      48             : #include <sys/timeval.h>
      49             : #else
      50             : #include <sys/socket.h>
      51             : #include <netinet/in.h>
      52             : #include <arpa/inet.h>
      53             : #ifndef _OSD_POSIX
      54             : #include <sys/errno.h>
      55             : #else
      56             : #include <errno.h>  /* BS2000/OSD uses <errno.h>, not <sys/errno.h> */
      57             : #endif
      58             : #include <netdb.h>
      59             : #endif
      60             : #ifdef HAVE_UNISTD_H
      61             : #include <unistd.h>
      62             : #endif
      63             : 
      64             : #ifndef __P
      65             : #ifdef __GNUC__
      66             : #define __P(args) args
      67             : #else
      68             : #define __P(args) ()
      69             : #endif
      70             : #endif
      71             : 
      72             : #ifdef HAVE_NET_SNMP
      73             : #include <net-snmp/net-snmp-config.h>
      74             : #include <net-snmp/net-snmp-includes.h>
      75             : #else
      76             : #ifdef HAVE_DEFAULT_STORE_H
      77             : #include "default_store.h"
      78             : #endif
      79             : #include "asn1.h"
      80             : #include "snmp_api.h"
      81             : #include "snmp_client.h"
      82             : #include "snmp_impl.h"
      83             : #include "snmp.h"
      84             : #include "snmpv3.h"
      85             : #include "keytools.h"
      86             : #include "parse.h"
      87             : #include "mib.h"
      88             : #ifndef PHP_WIN32
      89             : /* this doesn't appear to be needed under win32 (perhaps at all)
      90             :  * and the header file is not present in my UCD-SNMP headers */
      91             : # include "version.h"
      92             : #endif
      93             : #include "transform_oids.h"
      94             : #endif
      95             : /* Ugly macro, since the length of OIDs in UCD-SNMP and NET-SNMP
      96             :  * is different and this way the code is not full of 'ifdef's.
      97             :  */
      98             : #define OIDSIZE(p) (sizeof(p)/sizeof(oid))
      99             : 
     100             : /* For really old ucd-snmp versions.. */
     101             : #ifndef HAVE_SNMP_PARSE_OID
     102             : #define snmp_parse_oid read_objid
     103             : #endif
     104             : 
     105             : #define SNMP_VALUE_LIBRARY      0
     106             : #define SNMP_VALUE_PLAIN        1
     107             : #define SNMP_VALUE_OBJECT       2
     108             : 
     109             : ZEND_DECLARE_MODULE_GLOBALS(snmp)
     110             : static PHP_GINIT_FUNCTION(snmp);
     111             : 
     112             : /* constant - can be shared among threads */
     113             : static oid objid_mib[] = {1, 3, 6, 1, 2, 1};
     114             : 
     115             : /* {{{ arginfo */
     116             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmpget, 0, 0, 3)
     117             :         ZEND_ARG_INFO(0, host)
     118             :         ZEND_ARG_INFO(0, community)
     119             :         ZEND_ARG_INFO(0, object_id)
     120             :         ZEND_ARG_INFO(0, timeout)
     121             :         ZEND_ARG_INFO(0, retries)
     122             : ZEND_END_ARG_INFO()
     123             : 
     124             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmpgetnext, 0, 0, 3)
     125             :         ZEND_ARG_INFO(0, host)
     126             :         ZEND_ARG_INFO(0, community)
     127             :         ZEND_ARG_INFO(0, object_id)
     128             :         ZEND_ARG_INFO(0, timeout)
     129             :         ZEND_ARG_INFO(0, retries)
     130             : ZEND_END_ARG_INFO()
     131             : 
     132             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmpwalk, 0, 0, 3)
     133             :         ZEND_ARG_INFO(0, host)
     134             :         ZEND_ARG_INFO(0, community)
     135             :         ZEND_ARG_INFO(0, object_id)
     136             :         ZEND_ARG_INFO(0, timeout)
     137             :         ZEND_ARG_INFO(0, retries)
     138             : ZEND_END_ARG_INFO()
     139             : 
     140             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmprealwalk, 0, 0, 3)
     141             :         ZEND_ARG_INFO(0, host)
     142             :         ZEND_ARG_INFO(0, community)
     143             :         ZEND_ARG_INFO(0, object_id)
     144             :         ZEND_ARG_INFO(0, timeout)
     145             :         ZEND_ARG_INFO(0, retries)
     146             : ZEND_END_ARG_INFO()
     147             : 
     148             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_get_quick_print, 0, 0, 1)
     149             :         ZEND_ARG_INFO(0, d)
     150             : ZEND_END_ARG_INFO()
     151             : 
     152             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_set_quick_print, 0, 0, 1)
     153             :         ZEND_ARG_INFO(0, quick_print)
     154             : ZEND_END_ARG_INFO()
     155             : 
     156             : #ifdef HAVE_NET_SNMP
     157             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_set_enum_print, 0, 0, 1)
     158             :         ZEND_ARG_INFO(0, enum_print)
     159             : ZEND_END_ARG_INFO()
     160             : 
     161             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_set_oid_output_format, 0, 0, 1)
     162             :         ZEND_ARG_INFO(0, oid_format)
     163             : ZEND_END_ARG_INFO()
     164             : #endif
     165             : 
     166             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmpset, 0, 0, 5)
     167             :         ZEND_ARG_INFO(0, host)
     168             :         ZEND_ARG_INFO(0, community)
     169             :         ZEND_ARG_INFO(0, object_id)
     170             :         ZEND_ARG_INFO(0, type)
     171             :         ZEND_ARG_INFO(0, value)
     172             :         ZEND_ARG_INFO(0, timeout)
     173             :         ZEND_ARG_INFO(0, retries)
     174             : ZEND_END_ARG_INFO()
     175             : 
     176             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp2_get, 0, 0, 3)
     177             :         ZEND_ARG_INFO(0, host)
     178             :         ZEND_ARG_INFO(0, community)
     179             :         ZEND_ARG_INFO(0, object_id)
     180             :         ZEND_ARG_INFO(0, timeout)
     181             :         ZEND_ARG_INFO(0, retries)
     182             : ZEND_END_ARG_INFO()
     183             : 
     184             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp2_getnext, 0, 0, 3)
     185             :         ZEND_ARG_INFO(0, host)
     186             :         ZEND_ARG_INFO(0, community)
     187             :         ZEND_ARG_INFO(0, object_id)
     188             :         ZEND_ARG_INFO(0, timeout)
     189             :         ZEND_ARG_INFO(0, retries)
     190             : ZEND_END_ARG_INFO()
     191             : 
     192             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp2_walk, 0, 0, 3)
     193             :         ZEND_ARG_INFO(0, host)
     194             :         ZEND_ARG_INFO(0, community)
     195             :         ZEND_ARG_INFO(0, object_id)
     196             :         ZEND_ARG_INFO(0, timeout)
     197             :         ZEND_ARG_INFO(0, retries)
     198             : ZEND_END_ARG_INFO()
     199             : 
     200             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp2_real_walk, 0, 0, 3)
     201             :         ZEND_ARG_INFO(0, host)
     202             :         ZEND_ARG_INFO(0, community)
     203             :         ZEND_ARG_INFO(0, object_id)
     204             :         ZEND_ARG_INFO(0, timeout)
     205             :         ZEND_ARG_INFO(0, retries)
     206             : ZEND_END_ARG_INFO()
     207             : 
     208             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp2_set, 0, 0, 5)
     209             :         ZEND_ARG_INFO(0, host)
     210             :         ZEND_ARG_INFO(0, community)
     211             :         ZEND_ARG_INFO(0, object_id)
     212             :         ZEND_ARG_INFO(0, type)
     213             :         ZEND_ARG_INFO(0, value)
     214             :         ZEND_ARG_INFO(0, timeout)
     215             :         ZEND_ARG_INFO(0, retries)
     216             : ZEND_END_ARG_INFO()
     217             : 
     218             : ZEND_BEGIN_ARG_INFO_EX(arginfo_php_snmpv3, 0, 0, 2)
     219             :         ZEND_ARG_INFO(0, s)
     220             :         ZEND_ARG_INFO(0, st)
     221             : ZEND_END_ARG_INFO()
     222             : 
     223             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp3_get, 0, 0, 8)
     224             :         ZEND_ARG_INFO(0, host)
     225             :         ZEND_ARG_INFO(0, sec_name)
     226             :         ZEND_ARG_INFO(0, sec_level)
     227             :         ZEND_ARG_INFO(0, auth_protocol)
     228             :         ZEND_ARG_INFO(0, auth_passphrase)
     229             :         ZEND_ARG_INFO(0, priv_protocol)
     230             :         ZEND_ARG_INFO(0, priv_passphrase)
     231             :         ZEND_ARG_INFO(0, object_id)
     232             :         ZEND_ARG_INFO(0, timeout)
     233             :         ZEND_ARG_INFO(0, retries)
     234             : ZEND_END_ARG_INFO()
     235             : 
     236             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp3_getnext, 0, 0, 8)
     237             :         ZEND_ARG_INFO(0, host)
     238             :         ZEND_ARG_INFO(0, sec_name)
     239             :         ZEND_ARG_INFO(0, sec_level)
     240             :         ZEND_ARG_INFO(0, auth_protocol)
     241             :         ZEND_ARG_INFO(0, auth_passphrase)
     242             :         ZEND_ARG_INFO(0, priv_protocol)
     243             :         ZEND_ARG_INFO(0, priv_passphrase)
     244             :         ZEND_ARG_INFO(0, object_id)
     245             :         ZEND_ARG_INFO(0, timeout)
     246             :         ZEND_ARG_INFO(0, retries)
     247             : ZEND_END_ARG_INFO()
     248             : 
     249             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp3_walk, 0, 0, 8)
     250             :         ZEND_ARG_INFO(0, host)
     251             :         ZEND_ARG_INFO(0, sec_name)
     252             :         ZEND_ARG_INFO(0, sec_level)
     253             :         ZEND_ARG_INFO(0, auth_protocol)
     254             :         ZEND_ARG_INFO(0, auth_passphrase)
     255             :         ZEND_ARG_INFO(0, priv_protocol)
     256             :         ZEND_ARG_INFO(0, priv_passphrase)
     257             :         ZEND_ARG_INFO(0, object_id)
     258             :         ZEND_ARG_INFO(0, timeout)
     259             :         ZEND_ARG_INFO(0, retries)
     260             : ZEND_END_ARG_INFO()
     261             : 
     262             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp3_real_walk, 0, 0, 8)
     263             :         ZEND_ARG_INFO(0, host)
     264             :         ZEND_ARG_INFO(0, sec_name)
     265             :         ZEND_ARG_INFO(0, sec_level)
     266             :         ZEND_ARG_INFO(0, auth_protocol)
     267             :         ZEND_ARG_INFO(0, auth_passphrase)
     268             :         ZEND_ARG_INFO(0, priv_protocol)
     269             :         ZEND_ARG_INFO(0, priv_passphrase)
     270             :         ZEND_ARG_INFO(0, object_id)
     271             :         ZEND_ARG_INFO(0, timeout)
     272             :         ZEND_ARG_INFO(0, retries)
     273             : ZEND_END_ARG_INFO()
     274             : 
     275             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp3_set, 0, 0, 10)
     276             :         ZEND_ARG_INFO(0, host)
     277             :         ZEND_ARG_INFO(0, sec_name)
     278             :         ZEND_ARG_INFO(0, sec_level)
     279             :         ZEND_ARG_INFO(0, auth_protocol)
     280             :         ZEND_ARG_INFO(0, auth_passphrase)
     281             :         ZEND_ARG_INFO(0, priv_protocol)
     282             :         ZEND_ARG_INFO(0, priv_passphrase)
     283             :         ZEND_ARG_INFO(0, object_id)
     284             :         ZEND_ARG_INFO(0, type)
     285             :         ZEND_ARG_INFO(0, value)
     286             :         ZEND_ARG_INFO(0, timeout)
     287             :         ZEND_ARG_INFO(0, retries)
     288             : ZEND_END_ARG_INFO()
     289             : 
     290             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_set_valueretrieval, 0, 0, 1)
     291             :         ZEND_ARG_INFO(0, method)
     292             : ZEND_END_ARG_INFO()
     293             : 
     294             : ZEND_BEGIN_ARG_INFO(arginfo_snmp_get_valueretrieval, 0)
     295             : ZEND_END_ARG_INFO()
     296             : 
     297             : ZEND_BEGIN_ARG_INFO_EX(arginfo_snmp_read_mib, 0, 0, 1)
     298             :         ZEND_ARG_INFO(0, filename)
     299             : ZEND_END_ARG_INFO()
     300             : /* }}} */
     301             : 
     302             : /* {{{ snmp_functions[]
     303             :  */
     304             : const zend_function_entry snmp_functions[] = {
     305             :         PHP_FE(snmpget,                                                 arginfo_snmpget)
     306             :         PHP_FE(snmpgetnext,                                     arginfo_snmpgetnext)
     307             :         PHP_FE(snmpwalk,                                                arginfo_snmpwalk)
     308             :         PHP_FE(snmprealwalk,                                    arginfo_snmprealwalk)
     309             :         PHP_FALIAS(snmpwalkoid, snmprealwalk,   arginfo_snmprealwalk)
     310             :         PHP_FE(snmp_get_quick_print,                    arginfo_snmp_get_quick_print)
     311             :         PHP_FE(snmp_set_quick_print,                    arginfo_snmp_set_quick_print)
     312             : #ifdef HAVE_NET_SNMP
     313             :         PHP_FE(snmp_set_enum_print,                     arginfo_snmp_set_enum_print)
     314             :         PHP_FE(snmp_set_oid_output_format,              arginfo_snmp_set_oid_output_format)
     315             :         PHP_FALIAS(snmp_set_oid_numeric_print, snmp_set_oid_output_format, arginfo_snmp_set_oid_output_format)
     316             : #endif
     317             :         PHP_FE(snmpset,                                 arginfo_snmpset)
     318             : 
     319             :         PHP_FE(snmp2_get,                               arginfo_snmp2_get)
     320             :         PHP_FE(snmp2_getnext,                   arginfo_snmp2_getnext)
     321             :         PHP_FE(snmp2_walk,                              arginfo_snmp2_walk)
     322             :         PHP_FE(snmp2_real_walk,                 arginfo_snmp2_real_walk)
     323             :         PHP_FE(snmp2_set,                               arginfo_snmp2_set)
     324             : 
     325             :         PHP_FE(snmp3_get,                               arginfo_snmp3_get)
     326             :         PHP_FE(snmp3_getnext,                   arginfo_snmp3_getnext)
     327             :         PHP_FE(snmp3_walk,                              arginfo_snmp3_walk)
     328             :         PHP_FE(snmp3_real_walk,                 arginfo_snmp3_real_walk)
     329             :         PHP_FE(snmp3_set,                               arginfo_snmp3_set)
     330             :         PHP_FE(snmp_set_valueretrieval, arginfo_snmp_set_valueretrieval)
     331             :         PHP_FE(snmp_get_valueretrieval, arginfo_snmp_get_valueretrieval)
     332             : 
     333             :         PHP_FE(snmp_read_mib,                   arginfo_snmp_read_mib)
     334             :         PHP_FE_END
     335             : };
     336             : /* }}} */
     337             : 
     338             : #define SNMP_CMD_GET            1
     339             : #define SNMP_CMD_GETNEXT        2
     340             : #define SNMP_CMD_WALK           3
     341             : #define SNMP_CMD_REALWALK       4
     342             : #define SNMP_CMD_SET            11
     343             : 
     344             : /* {{{ snmp_module_entry
     345             :  */
     346             : zend_module_entry snmp_module_entry = {
     347             :         STANDARD_MODULE_HEADER,
     348             :         "snmp",
     349             :         snmp_functions,
     350             :         PHP_MINIT(snmp),
     351             :         PHP_MSHUTDOWN(snmp),
     352             :         NULL,
     353             :         NULL,
     354             :         PHP_MINFO(snmp),
     355             :         NO_VERSION_YET,
     356             :         PHP_MODULE_GLOBALS(snmp),
     357             :         PHP_GINIT(snmp),
     358             :         NULL,
     359             :         NULL,
     360             :         STANDARD_MODULE_PROPERTIES_EX
     361             : };
     362             : /* }}} */
     363             : 
     364             : #ifdef COMPILE_DL_SNMP
     365             : ZEND_GET_MODULE(snmp)
     366             : #endif
     367             : 
     368             : /* THREAD_LS snmp_module php_snmp_module; - may need one of these at some point */
     369             : 
     370             : /* {{{ PHP_GINIT_FUNCTION
     371             :  */
     372       19341 : static PHP_GINIT_FUNCTION(snmp)
     373             : {
     374       19341 :         snmp_globals->valueretrieval = SNMP_VALUE_LIBRARY;
     375       19341 : }
     376             : /* }}} */
     377             : 
     378             : /* {{{ PHP_MINIT_FUNCTION
     379             :  */
     380       19341 : PHP_MINIT_FUNCTION(snmp)
     381             : {
     382       19341 :         init_snmp("snmpapp");
     383             : 
     384             : #ifdef NETSNMP_DS_LIB_DONT_PERSIST_STATE
     385             :         /* Prevent update of the snmpapp.conf file */
     386       19341 :         netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_DONT_PERSIST_STATE, 1);
     387             : #endif
     388             : 
     389             : #ifdef HAVE_NET_SNMP
     390       19341 :         REGISTER_LONG_CONSTANT("SNMP_OID_OUTPUT_FULL", NETSNMP_OID_OUTPUT_FULL, CONST_CS | CONST_PERSISTENT);
     391       19341 :         REGISTER_LONG_CONSTANT("SNMP_OID_OUTPUT_NUMERIC", NETSNMP_OID_OUTPUT_NUMERIC, CONST_CS | CONST_PERSISTENT);
     392             : #endif
     393             : 
     394       19341 :         REGISTER_LONG_CONSTANT("SNMP_VALUE_LIBRARY", SNMP_VALUE_LIBRARY, CONST_CS | CONST_PERSISTENT);
     395       19341 :         REGISTER_LONG_CONSTANT("SNMP_VALUE_PLAIN", SNMP_VALUE_PLAIN, CONST_CS | CONST_PERSISTENT);
     396       19341 :         REGISTER_LONG_CONSTANT("SNMP_VALUE_OBJECT", SNMP_VALUE_OBJECT, CONST_CS | CONST_PERSISTENT);
     397             : 
     398       19341 :         REGISTER_LONG_CONSTANT("SNMP_BIT_STR", ASN_BIT_STR, CONST_CS | CONST_PERSISTENT);
     399       19341 :         REGISTER_LONG_CONSTANT("SNMP_OCTET_STR", ASN_OCTET_STR, CONST_CS | CONST_PERSISTENT);
     400       19341 :         REGISTER_LONG_CONSTANT("SNMP_OPAQUE", ASN_OPAQUE, CONST_CS | CONST_PERSISTENT);
     401       19341 :         REGISTER_LONG_CONSTANT("SNMP_NULL", ASN_NULL, CONST_CS | CONST_PERSISTENT);
     402       19341 :         REGISTER_LONG_CONSTANT("SNMP_OBJECT_ID", ASN_OBJECT_ID, CONST_CS | CONST_PERSISTENT);
     403       19341 :         REGISTER_LONG_CONSTANT("SNMP_IPADDRESS", ASN_IPADDRESS, CONST_CS | CONST_PERSISTENT);
     404       19341 :         REGISTER_LONG_CONSTANT("SNMP_COUNTER", ASN_GAUGE, CONST_CS | CONST_PERSISTENT);
     405       19341 :         REGISTER_LONG_CONSTANT("SNMP_UNSIGNED", ASN_UNSIGNED, CONST_CS | CONST_PERSISTENT);
     406       19341 :         REGISTER_LONG_CONSTANT("SNMP_TIMETICKS", ASN_TIMETICKS, CONST_CS | CONST_PERSISTENT);
     407       19341 :         REGISTER_LONG_CONSTANT("SNMP_UINTEGER", ASN_UINTEGER, CONST_CS | CONST_PERSISTENT);
     408       19341 :         REGISTER_LONG_CONSTANT("SNMP_INTEGER", ASN_INTEGER, CONST_CS | CONST_PERSISTENT);
     409       19341 :         REGISTER_LONG_CONSTANT("SNMP_COUNTER64", ASN_COUNTER64, CONST_CS | CONST_PERSISTENT);
     410             : 
     411       19341 :         return SUCCESS;
     412             : }
     413             : /* }}} */
     414             : 
     415             : /* {{{ PHP_MSHUTDOWN_FUNCTION
     416             :  */
     417       19376 : PHP_MSHUTDOWN_FUNCTION(snmp)
     418             : {
     419       19376 :         snmp_shutdown("snmpapp");
     420             : 
     421       19376 :         return SUCCESS;
     422             : }
     423             : /* }}} */
     424             : 
     425             : /* {{{ PHP_MINFO_FUNCTION
     426             :  */
     427         148 : PHP_MINFO_FUNCTION(snmp)
     428             : {
     429         148 :         php_info_print_table_start();
     430             : #ifdef HAVE_NET_SNMP
     431         148 :         php_info_print_table_row(2, "NET-SNMP Support", "enabled");
     432         148 :         php_info_print_table_row(2, "NET-SNMP Version", netsnmp_get_version());
     433             : #else
     434             :         php_info_print_table_row(2, "UCD-SNMP Support", "enabled");
     435             :         php_info_print_table_row(2, "UCD-SNMP Version", VersionInfo);
     436             : #endif
     437         148 :         php_info_print_table_end();
     438         148 : }
     439             : /* }}} */
     440             : 
     441           0 : static void php_snmp_getvalue(struct variable_list *vars, zval *snmpval TSRMLS_DC)
     442             : {
     443             :         zval *val;
     444             : #if I64CHARSZ > 2047
     445             :         char buf[I64CHARSZ + 1];
     446             : #else
     447             :         char buf[2048];
     448             : #endif
     449             : 
     450           0 :         buf[0] = 0;
     451             : 
     452           0 :         if (SNMP_G(valueretrieval) == SNMP_VALUE_LIBRARY) {
     453             : #ifdef HAVE_NET_SNMP
     454           0 :                 snprint_value(buf, sizeof(buf), vars->name, vars->name_length, vars);
     455             : #else
     456             :                 sprint_value(buf,vars->name, vars->name_length, vars);
     457             : #endif
     458           0 :                 ZVAL_STRING(snmpval, buf, 1);
     459           0 :                 return;
     460             :         }
     461             : 
     462           0 :         MAKE_STD_ZVAL(val);
     463             : 
     464           0 :         switch (vars->type) {
     465             :         case ASN_BIT_STR:               /* 0x03, asn1.h */
     466           0 :                 ZVAL_STRINGL(val, vars->val.bitstring, vars->val_len, 1);
     467           0 :                 break;
     468             : 
     469             :         case ASN_OCTET_STR:             /* 0x04, asn1.h */
     470             :         case ASN_OPAQUE:                /* 0x44, snmp_impl.h */
     471           0 :                 ZVAL_STRINGL(val, vars->val.string, vars->val_len, 1);
     472           0 :                 break;
     473             : 
     474             :         case ASN_NULL:                  /* 0x05, asn1.h */
     475           0 :                 ZVAL_NULL(val);
     476           0 :                 break;
     477             : 
     478             :         case ASN_OBJECT_ID:             /* 0x06, asn1.h */
     479             : #ifdef HAVE_NET_SNMP
     480           0 :                 snprint_objid(buf, sizeof(buf), vars->val.objid, vars->val_len / sizeof(oid));
     481             : #else
     482             :                 sprint_objid(buf, vars->val.objid, vars->val_len / sizeof(oid));
     483             : #endif
     484             : 
     485           0 :                 ZVAL_STRING(val, buf, 1);
     486           0 :                 break;
     487             : 
     488             :         case ASN_IPADDRESS:             /* 0x40, snmp_impl.h */
     489           0 :                 snprintf(buf, sizeof(buf)-1, "%d.%d.%d.%d",
     490           0 :                          (vars->val.string)[0], (vars->val.string)[1],
     491           0 :                          (vars->val.string)[2], (vars->val.string)[3]);
     492           0 :                 buf[sizeof(buf)-1]=0;
     493           0 :                 ZVAL_STRING(val, buf, 1);
     494           0 :                 break;
     495             : 
     496             :         case ASN_COUNTER:               /* 0x41, snmp_impl.h */
     497             :         case ASN_GAUGE:                 /* 0x42, snmp_impl.h */
     498             :         /* ASN_UNSIGNED is the same as ASN_GAUGE */
     499             :         case ASN_TIMETICKS:             /* 0x43, snmp_impl.h */
     500             :         case ASN_UINTEGER:              /* 0x47, snmp_impl.h */
     501           0 :                 snprintf(buf, sizeof(buf)-1, "%lu", *vars->val.integer);
     502           0 :                 buf[sizeof(buf)-1]=0;
     503           0 :                 ZVAL_STRING(val, buf, 1);
     504           0 :                 break;
     505             : 
     506             :         case ASN_INTEGER:               /* 0x02, asn1.h */
     507           0 :                 snprintf(buf, sizeof(buf)-1, "%ld", *vars->val.integer);
     508           0 :                 buf[sizeof(buf)-1]=0;
     509           0 :                 ZVAL_STRING(val, buf, 1);
     510           0 :                 break;
     511             : 
     512             :         case ASN_COUNTER64:             /* 0x46, snmp_impl.h */
     513           0 :                 printU64(buf, vars->val.counter64);
     514           0 :                 ZVAL_STRING(val, buf, 1);
     515           0 :                 break;
     516             : 
     517             :         default:
     518           0 :                 ZVAL_STRING(val, "Unknown value type", 1);
     519             :                 break;
     520             :         }
     521             : 
     522           0 :         if (SNMP_G(valueretrieval) == SNMP_VALUE_PLAIN) {
     523           0 :                 *snmpval = *val;
     524           0 :                 zval_copy_ctor(snmpval);
     525             :         } else {
     526           0 :                 object_init(snmpval);
     527           0 :                 add_property_long(snmpval, "type", vars->type);
     528           0 :                 add_property_zval(snmpval, "value", val);
     529             :         }
     530             : }
     531             : 
     532             : /* {{{ php_snmp_internal
     533             : *
     534             : * Generic SNMP object fetcher (for all SNMP versions)
     535             : *
     536             : * st=SNMP_CMD_GET   get - query an agent with SNMP-GET.
     537             : * st=SNMP_CMD_GETNEXT   getnext - query an agent with SNMP-GETNEXT.
     538             : * st=SNMP_CMD_WALK   walk - walk the mib and return a single dimensional array 
     539             : *          containing the values.
     540             : * st=SNMP_CMD_REALWALK   realwalk() and walkoid() - walk the mib and return an 
     541             : *          array of oid,value pairs.
     542             : * st=SNMP_CMD_SET  set() - query an agent and set a single value
     543             : *
     544             : */
     545           0 : static void php_snmp_internal(INTERNAL_FUNCTION_PARAMETERS, int st, 
     546             :                                                         struct snmp_session *session,
     547             :                                                         char *objid,
     548             :                                                         char type,
     549             :                                                         char* value) 
     550             : {
     551             :         struct snmp_session *ss;
     552           0 :         struct snmp_pdu *pdu=NULL, *response;
     553             :         struct variable_list *vars;
     554             :         oid name[MAX_NAME_LEN];
     555             :         size_t name_length;
     556             :         oid root[MAX_NAME_LEN];
     557           0 :         size_t rootlen = 0;
     558           0 :         int gotroot = 0;
     559             :         int status, count;
     560             :         char buf[2048];
     561             :         char buf2[2048];
     562           0 :         int keepwalking=1;
     563             :         char *err;
     564           0 :         zval *snmpval = NULL;
     565             : 
     566           0 :         if (st >= SNMP_CMD_WALK) { /* walk */
     567           0 :                 rootlen = MAX_NAME_LEN;
     568           0 :                 if (strlen(objid)) { /* on a walk, an empty string means top of tree - no error */
     569           0 :                         if (snmp_parse_oid(objid, root, &rootlen)) {
     570           0 :                                 gotroot = 1;
     571             :                         } else {
     572           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid object identifier: %s", objid);
     573             :                         }
     574             :                 }
     575             : 
     576           0 :                 if (!gotroot) {
     577           0 :                         memmove((char *) root, (char *) objid_mib, sizeof(objid_mib));
     578           0 :                         rootlen = sizeof(objid_mib) / sizeof(oid);
     579           0 :                         gotroot = 1;
     580             :                 }
     581             :         }
     582             : 
     583           0 :         if ((ss = snmp_open(session)) == NULL) {
     584           0 :                 snmp_error(session, NULL, NULL, &err);
     585           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not open snmp connection: %s", err);
     586           0 :                 free(err);
     587           0 :                 RETURN_FALSE;
     588             :         }
     589             : 
     590           0 :         if (st >= SNMP_CMD_WALK) {
     591           0 :                 memmove((char *)name, (char *)root, rootlen * sizeof(oid));
     592           0 :                 name_length = rootlen;
     593           0 :                 switch(st) {
     594             :                         case SNMP_CMD_WALK:
     595             :                         case SNMP_CMD_REALWALK:
     596           0 :                                 array_init(return_value);
     597           0 :                                 break;
     598             :                         default:
     599           0 :                                 RETVAL_TRUE;
     600             :                                 break;
     601             :                 }
     602             :         }
     603             : 
     604           0 :         while (keepwalking) {
     605           0 :                 keepwalking = 0;
     606           0 :                 if ((st == SNMP_CMD_GET) || (st == SNMP_CMD_GETNEXT)) {
     607           0 :                         name_length = MAX_OID_LEN;
     608           0 :                         if (!snmp_parse_oid(objid, name, &name_length)) {
     609           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid object identifier: %s", objid);
     610           0 :                                 snmp_close(ss);
     611           0 :                                 RETURN_FALSE;
     612             :                         }
     613           0 :                         pdu = snmp_pdu_create((st == SNMP_CMD_GET) ? SNMP_MSG_GET : SNMP_MSG_GETNEXT);
     614           0 :                         snmp_add_null_var(pdu, name, name_length);
     615           0 :                 } else if (st == SNMP_CMD_SET) {
     616           0 :                         pdu = snmp_pdu_create(SNMP_MSG_SET);
     617           0 :                         if (snmp_add_var(pdu, name, name_length, type, value)) {
     618             : #ifdef HAVE_NET_SNMP
     619           0 :                                 snprint_objid(buf, sizeof(buf), name, name_length);
     620             : #else
     621             :                                 sprint_objid(buf, name, name_length);
     622             : #endif
     623           0 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not add variable: %s %c %s", buf, type, value);
     624           0 :                                 snmp_free_pdu(pdu);
     625           0 :                                 snmp_close(ss);
     626           0 :                                 RETURN_FALSE;
     627             :                         }
     628           0 :                 } else if (st >= SNMP_CMD_WALK) {
     629           0 :                         if (session->version == SNMP_VERSION_1) {
     630           0 :                                 pdu = snmp_pdu_create(SNMP_MSG_GETNEXT);
     631             :                         } else {
     632           0 :                                 pdu = snmp_pdu_create(SNMP_MSG_GETBULK);
     633           0 :                                 pdu->non_repeaters = 0;
     634           0 :                                 pdu->max_repetitions = 20;
     635             :                         }
     636           0 :                         snmp_add_null_var(pdu, name, name_length);
     637             :                 }
     638             : 
     639             : retry:
     640           0 :                 status = snmp_synch_response(ss, pdu, &response);
     641           0 :                 if (status == STAT_SUCCESS) {
     642           0 :                         if (response->errstat == SNMP_ERR_NOERROR) {
     643           0 :                                 for (vars = response->variables; vars; vars = vars->next_variable) {
     644           0 :                                         if (st >= SNMP_CMD_WALK && st != SNMP_CMD_SET && 
     645           0 :                                                 (vars->name_length < rootlen || memcmp(root, vars->name, rootlen * sizeof(oid)))) {
     646           0 :                                                 continue;       /* not part of this subtree */
     647             :                                         }
     648             : 
     649           0 :                                         if (st != SNMP_CMD_SET) {
     650           0 :                                                 MAKE_STD_ZVAL(snmpval);
     651           0 :                                                 php_snmp_getvalue(vars, snmpval TSRMLS_CC);
     652             :                                         }
     653             : 
     654           0 :                                         if (st == SNMP_CMD_GET) {
     655           0 :                                                 *return_value = *snmpval;
     656           0 :                                                 zval_copy_ctor(return_value);
     657           0 :                                                 zval_ptr_dtor(&snmpval);
     658           0 :                                                 snmp_free_pdu(response);
     659           0 :                                                 snmp_close(ss);
     660           0 :                                                 return;
     661           0 :                                         } else if (st == SNMP_CMD_GETNEXT) {
     662           0 :                                                 *return_value = *snmpval;
     663           0 :                                                 zval_copy_ctor(return_value);
     664           0 :                                                 snmp_free_pdu(response);
     665           0 :                                                 snmp_close(ss);
     666           0 :                                                 return;
     667           0 :                                         } else if (st == SNMP_CMD_WALK) {
     668           0 :                                                 add_next_index_zval(return_value,snmpval); /* Add to returned array */
     669           0 :                                         } else if (st == SNMP_CMD_REALWALK && vars->type != SNMP_ENDOFMIBVIEW && vars->type != SNMP_NOSUCHOBJECT && vars->type != SNMP_NOSUCHINSTANCE) {
     670             : #ifdef HAVE_NET_SNMP
     671           0 :                                                 snprint_objid(buf2, sizeof(buf2), vars->name, vars->name_length);
     672             : #else
     673             :                                                 sprint_objid(buf2, vars->name, vars->name_length);
     674             : #endif
     675           0 :                                                 add_assoc_zval(return_value,buf2,snmpval);
     676             :                                         }
     677           0 :                                         if (st >= SNMP_CMD_WALK && st != SNMP_CMD_SET) {
     678           0 :                                                 if (vars->type != SNMP_ENDOFMIBVIEW && 
     679           0 :                                                         vars->type != SNMP_NOSUCHOBJECT && vars->type != SNMP_NOSUCHINSTANCE) {
     680           0 :                                                         if (snmp_oid_compare(name, name_length, vars->name, vars->name_length) >= 0) {
     681           0 :                                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error: OID not increasing: %s",name);
     682           0 :                                                                 keepwalking = 0;
     683             :                                                         } else {
     684           0 :                                                                 memmove((char *)name, (char *)vars->name,vars->name_length * sizeof(oid));
     685           0 :                                                                 name_length = vars->name_length;
     686           0 :                                                                 keepwalking = 1;
     687             :                                                         }
     688             :                                                 }
     689             :                                         }
     690             :                                 }       
     691             :                         } else {
     692           0 :                                 if ((st != SNMP_CMD_WALK && st != SNMP_CMD_REALWALK) || response->errstat != SNMP_ERR_NOSUCHNAME) {
     693           0 :                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error in packet: %s", snmp_errstring(response->errstat));
     694           0 :                                         if (response->errstat == SNMP_ERR_NOSUCHNAME) {
     695           0 :                                                 for (count=1, vars = response->variables; vars && count != response->errindex;
     696           0 :                                                 vars = vars->next_variable, count++);
     697           0 :                                                 if (vars) {
     698             : #ifdef HAVE_NET_SNMP
     699           0 :                                                         snprint_objid(buf, sizeof(buf), vars->name, vars->name_length);
     700             : #else
     701             :                                                         sprint_objid(buf,vars->name, vars->name_length);
     702             : #endif
     703             :                                                 }
     704           0 :                                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "This name does not exist: %s",buf);
     705             :                                         }
     706           0 :                                         if (st == SNMP_CMD_GET) {
     707           0 :                                                 if ((pdu = snmp_fix_pdu(response, SNMP_MSG_GET)) != NULL) {
     708           0 :                                                         snmp_free_pdu(response);
     709           0 :                                                         goto retry;
     710             :                                                 }
     711           0 :                                         } else if (st == SNMP_CMD_SET) {
     712           0 :                                                 if ((pdu = snmp_fix_pdu(response, SNMP_MSG_SET)) != NULL) {
     713           0 :                                                         snmp_free_pdu(response);
     714           0 :                                                         goto retry;
     715             :                                                 }
     716           0 :                                         } else if (st == SNMP_CMD_GETNEXT) {
     717           0 :                                                 if ((pdu = snmp_fix_pdu(response, SNMP_MSG_GETNEXT)) != NULL) {
     718           0 :                                                         snmp_free_pdu(response);
     719           0 :                                                         goto retry;
     720             :                                                 }
     721           0 :                                         } else if (st >= SNMP_CMD_WALK) { /* Here we do walks. */
     722           0 :                                                 if ((pdu = snmp_fix_pdu(response, ((session->version == SNMP_VERSION_1)
     723             :                                                                                 ? SNMP_MSG_GETNEXT
     724             :                                                                                 : SNMP_MSG_GETBULK))) != NULL) {
     725           0 :                                                         snmp_free_pdu(response);
     726           0 :                                                         goto retry;
     727             :                                                 }
     728             :                                         }
     729           0 :                                         snmp_free_pdu(response);
     730           0 :                                         snmp_close(ss);
     731           0 :                                         if (st == SNMP_CMD_WALK || st == SNMP_CMD_REALWALK) {
     732           0 :                                                 zval_dtor(return_value);
     733             :                                         }
     734           0 :                                         RETURN_FALSE;
     735             :                                 }
     736             :                         }
     737           0 :                 } else if (status == STAT_TIMEOUT) {
     738           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "No response from %s", session->peername);
     739           0 :                         if (st == SNMP_CMD_WALK || st == SNMP_CMD_REALWALK) {
     740           0 :                                 zval_dtor(return_value);
     741             :                         }
     742           0 :                         snmp_close(ss);
     743           0 :                         RETURN_FALSE;
     744             :                 } else {    /* status == STAT_ERROR */
     745           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred, quitting");
     746           0 :                         if (st == SNMP_CMD_WALK || st == SNMP_CMD_REALWALK) {
     747           0 :                                 zval_dtor(return_value);
     748             :                         }
     749           0 :                         snmp_close(ss);
     750           0 :                         RETURN_FALSE;
     751             :                 }
     752           0 :                 if (response) {
     753           0 :                         snmp_free_pdu(response);
     754             :                 }
     755             :         } /* keepwalking */
     756           0 :         snmp_close(ss);
     757             : }
     758             : /* }}} */
     759             : 
     760             : /* {{{ php_snmp
     761             : *
     762             : * Generic community based SNMP handler for version 1 and 2.
     763             : * This function makes use of the internal SNMP object fetcher.
     764             : * The object fetcher is shared with SNMPv3.
     765             : *
     766             : * st=SNMP_CMD_GET   get - query an agent with SNMP-GET.
     767             : * st=SNMP_CMD_GETNEXT   getnext - query an agent with SNMP-GETNEXT.
     768             : * st=SNMP_CMD_WALK   walk - walk the mib and return a single dimensional array 
     769             : *          containing the values.
     770             : * st=SNMP_CMD_REALWALK   realwalk() and walkoid() - walk the mib and return an 
     771             : *          array of oid,value pairs.
     772             : * st=5-8 ** Reserved **
     773             : * st=SNMP_CMD_SET  set() - query an agent and set a single value
     774             : *
     775             : */
     776           0 : static void php_snmp(INTERNAL_FUNCTION_PARAMETERS, int st, int version) 
     777             : {
     778             :         char *a1, *a2, *a3;
     779             :         int a1_len, a2_len, a3_len;
     780             :         struct snmp_session session;
     781           0 :         long timeout = SNMP_DEFAULT_TIMEOUT;
     782           0 :         long retries = SNMP_DEFAULT_RETRIES;
     783           0 :         char type = (char) 0;
     784           0 :         char *value = (char *) 0, *stype = "";
     785             :         int value_len, stype_len;
     786             :         char hostname[MAX_NAME_LEN];
     787           0 :         int remote_port = 161;
     788             :         char *pptr;
     789           0 :         int argc = ZEND_NUM_ARGS();
     790             : 
     791           0 :         if (st == SNMP_CMD_SET) {
     792           0 :                 if (zend_parse_parameters(argc TSRMLS_CC, "sssss|ll", &a1, &a1_len, &a2, &a2_len, &a3, &a3_len, &stype, &stype_len, &value, &value_len, &timeout, &retries) == FAILURE) {
     793           0 :                         return;
     794             :                 }
     795             :         } else {
     796             :                 /* SNMP_CMD_GET
     797             :                  * SNMP_CMD_GETNEXT
     798             :                  * SNMP_CMD_WALK
     799             :                  * SNMP_CMD_REALWALK
     800             :                  */
     801           0 :                 if (zend_parse_parameters(argc TSRMLS_CC, "sss|ll", &a1, &a1_len, &a2, &a2_len, &a3, &a3_len, &timeout, &retries) == FAILURE) {
     802           0 :                         return;
     803             :                 }
     804             :         }
     805             :         
     806           0 :         if (st == SNMP_CMD_SET) {
     807           0 :                 type = stype[0];
     808             :         } 
     809             : 
     810           0 :         snmp_sess_init(&session);
     811           0 :         strlcpy(hostname, a1, sizeof(hostname));
     812           0 :         if ((pptr = strchr (hostname, ':'))) {
     813           0 :                 remote_port = strtol (pptr + 1, NULL, 0);
     814             :         }
     815             : 
     816           0 :         session.peername = hostname;
     817           0 :         session.remote_port = remote_port;
     818           0 :         session.version = version;
     819             :         /*
     820             :         * FIXME: potential memory leak
     821             :         * This is a workaround for an "artifact" (Mike Slifcak)
     822             :         * in (at least) ucd-snmp 3.6.1 which frees
     823             :         * memory it did not allocate
     824             :         */
     825             : #ifdef UCD_SNMP_HACK
     826             :         session.community = (u_char *)strdup(a2); /* memory freed by SNMP library, strdup NOT estrdup */
     827             : #else
     828           0 :         session.community = (u_char *)a2;
     829             : #endif
     830           0 :         session.community_len = a2_len;
     831           0 :         session.retries = retries;
     832           0 :         session.timeout = timeout;
     833             :         
     834           0 :         session.authenticator = NULL;
     835             : 
     836           0 :         php_snmp_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU, st, &session, a3, type, value);
     837             : }
     838             : /* }}} */
     839             : 
     840             : /* {{{ proto string snmpget(string host, string community, string object_id [, int timeout [, int retries]]) 
     841             :    Fetch a SNMP object */
     842           0 : PHP_FUNCTION(snmpget)
     843             : {
     844           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_GET, SNMP_VERSION_1);
     845           0 : }
     846             : /* }}} */
     847             : 
     848             : /* {{{ proto string snmpgetnext(string host, string community, string object_id [, int timeout [, int retries]]) 
     849             :    Fetch a SNMP object */
     850           0 : PHP_FUNCTION(snmpgetnext)
     851             : {
     852           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_GETNEXT, SNMP_VERSION_1);
     853           0 : }
     854             : /* }}} */
     855             : 
     856             : /* {{{ proto array snmpwalk(string host, string community, string object_id [, int timeout [, int retries]]) 
     857             :    Return all objects under the specified object id */
     858           0 : PHP_FUNCTION(snmpwalk)
     859             : {
     860           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_WALK, SNMP_VERSION_1);
     861           0 : }
     862             : /* }}} */
     863             : 
     864             : /* {{{ proto array snmprealwalk(string host, string community, string object_id [, int timeout [, int retries]])
     865             :    Return all objects including their respective object id withing the specified one */
     866           0 : PHP_FUNCTION(snmprealwalk)
     867             : {
     868           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_REALWALK, SNMP_VERSION_1);
     869           0 : }
     870             : /* }}} */
     871             : 
     872             : /* {{{ proto bool snmp_get_quick_print(void)
     873             :    Return the current status of quick_print */
     874           0 : PHP_FUNCTION(snmp_get_quick_print)
     875             : {
     876           0 :         if (zend_parse_parameters_none() == FAILURE) {
     877           0 :                 return;
     878             :         }
     879             : 
     880             : #ifdef HAVE_NET_SNMP
     881           0 :         RETURN_BOOL(netsnmp_ds_get_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_QUICK_PRINT));
     882             : #else
     883             :         RETURN_BOOL(snmp_get_quick_print());
     884             : #endif
     885             : }
     886             : /* }}} */
     887             : 
     888             : /* {{{ proto void snmp_set_quick_print(int quick_print)
     889             :    Return all objects including their respective object id withing the specified one */
     890           0 : PHP_FUNCTION(snmp_set_quick_print)
     891             : {
     892             :         long a1;
     893             : 
     894           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &a1) == FAILURE) {
     895           0 :                 return;
     896             :         }
     897             : 
     898             : #ifdef HAVE_NET_SNMP
     899           0 :         netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_QUICK_PRINT, (int) a1);
     900             : #else
     901             :         snmp_set_quick_print((int)a1);
     902             : #endif
     903             : }
     904             : /* }}} */
     905             : 
     906             : #ifdef HAVE_NET_SNMP
     907             : /* {{{ proto void snmp_set_enum_print(int enum_print)
     908             :    Return all values that are enums with their enum value instead of the raw integer */
     909           0 : PHP_FUNCTION(snmp_set_enum_print)
     910             : {
     911             :         long a1;
     912             : 
     913           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &a1) == FAILURE) {
     914           0 :                 return;
     915             :         }
     916             : 
     917           0 :         netsnmp_ds_set_boolean(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_PRINT_NUMERIC_ENUM, (int) a1);
     918             : } 
     919             : /* }}} */
     920             : 
     921             : /* {{{ proto void snmp_set_oid_output_format(int oid_format)
     922             :    Set the OID output format. */
     923           0 : PHP_FUNCTION(snmp_set_oid_output_format)
     924             : {
     925             :         long a1;
     926             : 
     927           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &a1) == FAILURE) {
     928           0 :                 return;
     929             :         }
     930             : 
     931           0 :         switch ((int) a1) {
     932             :                 case 0:
     933             :                 case NETSNMP_OID_OUTPUT_FULL:
     934           0 :                         a1 = NETSNMP_OID_OUTPUT_FULL;
     935           0 :                         break;
     936             : 
     937             :                 default:
     938             :                 case NETSNMP_OID_OUTPUT_NUMERIC:
     939           0 :                         a1 = NETSNMP_OID_OUTPUT_NUMERIC;
     940             :                         break;
     941             :         }
     942             : 
     943           0 :         netsnmp_ds_set_int(NETSNMP_DS_LIBRARY_ID, NETSNMP_DS_LIB_OID_OUTPUT_FORMAT, a1);
     944             : } 
     945             : /* }}} */
     946             : #endif
     947             : 
     948             : /* {{{ proto int snmpset(string host, string community, string object_id, string type, mixed value [, int timeout [, int retries]]) 
     949             :    Set the value of a SNMP object */
     950           0 : PHP_FUNCTION(snmpset)
     951             : {
     952           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_SET, SNMP_VERSION_1);
     953           0 : }
     954             : /* }}} */
     955             : 
     956             : /* {{{ int netsnmp_session_set_sec_name(struct snmp_session *s, char *name)
     957             :    Set the security name in the snmpv3 session */
     958           0 : static int netsnmp_session_set_sec_name(struct snmp_session *s, char *name)
     959             : {
     960           0 :         if ((s) && (name)) {
     961           0 :                 s->securityName = strdup(name);
     962           0 :                 s->securityNameLen = strlen(s->securityName);
     963           0 :                 return (0);
     964             :         }
     965           0 :         return (-1);
     966             : }
     967             : /* }}} */
     968             : 
     969             : /* {{{ int netsnmp_session_set_sec_level(struct snmp_session *s, char *level)
     970             :    Set the security level in the snmpv3 session */
     971           0 : static int netsnmp_session_set_sec_level(struct snmp_session *s, char *level TSRMLS_DC)
     972             : {
     973           0 :         if ((s) && (level)) {
     974           0 :                 if (!strcasecmp(level, "noAuthNoPriv") || !strcasecmp(level, "nanp")) {
     975           0 :                         s->securityLevel = SNMP_SEC_LEVEL_NOAUTH;
     976           0 :                         return (0);
     977           0 :                 } else if (!strcasecmp(level, "authNoPriv") || !strcasecmp(level, "anp")) {
     978           0 :                         s->securityLevel = SNMP_SEC_LEVEL_AUTHNOPRIV;
     979           0 :                         return (0);
     980           0 :                 } else if (!strcasecmp(level, "authPriv") || !strcasecmp(level, "ap")) {
     981           0 :                         s->securityLevel = SNMP_SEC_LEVEL_AUTHPRIV;
     982           0 :                         return (0);
     983             :                 }
     984             :         }
     985           0 :         return (-1);
     986             : }
     987             : /* }}} */
     988             : 
     989             : /* {{{ int netsnmp_session_set_auth_protocol(struct snmp_session *s, char *prot)
     990             :    Set the authentication protocol in the snmpv3 session */
     991           0 : static int netsnmp_session_set_auth_protocol(struct snmp_session *s, char *prot TSRMLS_DC)
     992             : {
     993           0 :         if ((s) && (prot)) {
     994           0 :                 if (!strcasecmp(prot, "MD5")) {
     995           0 :                         s->securityAuthProto = usmHMACMD5AuthProtocol;
     996           0 :                         s->securityAuthProtoLen = OIDSIZE(usmHMACMD5AuthProtocol);
     997           0 :                         return (0);
     998           0 :                 } else if (!strcasecmp(prot, "SHA")) {
     999           0 :                         s->securityAuthProto = usmHMACSHA1AuthProtocol;
    1000           0 :                         s->securityAuthProtoLen = OIDSIZE(usmHMACSHA1AuthProtocol);
    1001           0 :                         return (0);
    1002             :                 }
    1003             :         }
    1004           0 :         return (-1);
    1005             : }
    1006             : /* }}} */
    1007             : 
    1008             : /* {{{ int netsnmp_session_set_sec_protocol(struct snmp_session *s, char *prot)
    1009             :    Set the security protocol in the snmpv3 session */
    1010           0 : static int netsnmp_session_set_sec_protocol(struct snmp_session *s, char *prot TSRMLS_DC)
    1011             : {
    1012           0 :         if ((s) && (prot)) {
    1013           0 :                 if (!strcasecmp(prot, "DES")) {
    1014           0 :                         s->securityPrivProto = usmDESPrivProtocol;
    1015           0 :                         s->securityPrivProtoLen = OIDSIZE(usmDESPrivProtocol);
    1016           0 :                         return (0);
    1017             : #ifdef HAVE_AES
    1018           0 :                 } else if (!strcasecmp(prot, "AES128")
    1019             : #ifdef SNMP_VALIDATE_ERR
    1020             : /* 
    1021             : * In Net-SNMP before 5.2, the following symbols exist:
    1022             : * usmAES128PrivProtocol, usmAES192PrivProtocol, usmAES256PrivProtocol
    1023             : * In an effort to be more standards-compliant, 5.2 removed the last two.
    1024             : * As of 5.2, the symbols are:
    1025             : * usmAESPrivProtocol, usmAES128PrivProtocol
    1026             : * 
    1027             : * As we want this extension to compile on both versions, we use the latter
    1028             : * symbol on purpose, as it's defined to be the same as the former.
    1029             : *
    1030             : * However, in 5.2 the type of usmAES128PrivProtocol is a pointer, not an
    1031             : * array, so we cannot use the OIDSIZE macro because it uses sizeof().
    1032             : *
    1033             : */
    1034           0 :                         || !strcasecmp(prot, "AES")) {
    1035           0 :                         s->securityPrivProto = usmAES128PrivProtocol;
    1036           0 :                         s->securityPrivProtoLen = USM_PRIV_PROTO_AES128_LEN;
    1037           0 :                         return (0);
    1038             : #else                   
    1039             :                 ) {
    1040             :                         s->securityPrivProto = usmAES128PrivProtocol;
    1041             :                         s->securityPrivProtoLen = OIDSIZE(usmAES128PrivProtocol);
    1042             :                         return (0);
    1043             :                 } else if (!strcasecmp(prot, "AES192")) {
    1044             :                         s->securityPrivProto = usmAES192PrivProtocol;
    1045             :                         s->securityPrivProtoLen = OIDSIZE(usmAES192PrivProtocol);
    1046             :                         return (0);
    1047             :                 } else if (!strcasecmp(prot, "AES256")) {
    1048             :                         s->securityPrivProto = usmAES256PrivProtocol;
    1049             :                         s->securityPrivProtoLen = OIDSIZE(usmAES256PrivProtocol);
    1050             :                         return (0);
    1051             : #endif
    1052             : #endif
    1053             :                 }
    1054             :         }
    1055           0 :         return (-1);
    1056             : }
    1057             : /* }}} */
    1058             : 
    1059             : /* {{{ int netsnmp_session_gen_auth_key(struct snmp_session *s, char *pass)
    1060             :    Make key from pass phrase in the snmpv3 session */
    1061           0 : static int netsnmp_session_gen_auth_key(struct snmp_session *s, char *pass TSRMLS_DC)
    1062             : {
    1063             :         /*
    1064             :          * make master key from pass phrases 
    1065             :          */
    1066           0 :         if ((s) && (pass) && strlen(pass)) {
    1067           0 :                 s->securityAuthKeyLen = USM_AUTH_KU_LEN;
    1068           0 :                 if (s->securityAuthProto == NULL) {
    1069             :                         /* get .conf set default */
    1070           0 :                         const oid *def = get_default_authtype(&(s->securityAuthProtoLen));
    1071           0 :                         s->securityAuthProto = snmp_duplicate_objid(def, s->securityAuthProtoLen);
    1072             :                 }
    1073           0 :                 if (s->securityAuthProto == NULL) {
    1074             :                         /* assume MD5 */
    1075           0 :                         s->securityAuthProto =
    1076           0 :                                 snmp_duplicate_objid(usmHMACMD5AuthProtocol, OIDSIZE(usmHMACMD5AuthProtocol));
    1077           0 :                         s->securityAuthProtoLen = OIDSIZE(usmHMACMD5AuthProtocol);
    1078             :                 }
    1079           0 :                 if (generate_Ku(s->securityAuthProto, s->securityAuthProtoLen,
    1080             :                                 (u_char *) pass, strlen(pass),
    1081             :                                 s->securityAuthKey, &(s->securityAuthKeyLen)) != SNMPERR_SUCCESS) {
    1082           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error generating a key for authentication pass phrase");
    1083           0 :                         return (-2);
    1084             :                 }
    1085           0 :                 return (0);
    1086             :         }
    1087           0 :         return (-1);
    1088             : }
    1089             : /* }}} */
    1090             : 
    1091             : /* {{{ int netsnmp_session_gen_sec_key(struct snmp_session *s, u_char *pass)
    1092             :    Make key from pass phrase in the snmpv3 session */
    1093           0 : static int netsnmp_session_gen_sec_key(struct snmp_session *s, u_char *pass TSRMLS_DC)
    1094             : {
    1095           0 :         if ((s) && (pass) && strlen(pass)) {
    1096           0 :                 s->securityPrivKeyLen = USM_PRIV_KU_LEN;
    1097           0 :                 if (s->securityPrivProto == NULL) {
    1098             :                         /* get .conf set default */
    1099           0 :                         const oid *def = get_default_privtype(&(s->securityPrivProtoLen));
    1100           0 :                         s->securityPrivProto = snmp_duplicate_objid(def, s->securityPrivProtoLen);
    1101             :                 }
    1102           0 :                 if (s->securityPrivProto == NULL) {
    1103             :                         /* assume DES */
    1104           0 :                         s->securityPrivProto = snmp_duplicate_objid(usmDESPrivProtocol,
    1105             :                                 OIDSIZE(usmDESPrivProtocol));
    1106           0 :                         s->securityPrivProtoLen = OIDSIZE(usmDESPrivProtocol);
    1107             :                 }
    1108           0 :                 if (generate_Ku(s->securityAuthProto, s->securityAuthProtoLen,
    1109             :                                 pass, strlen(pass),
    1110             :                                 s->securityPrivKey, &(s->securityPrivKeyLen)) != SNMPERR_SUCCESS) {
    1111           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error generating a key for privacy pass phrase");
    1112           0 :                         return (-2);
    1113             :                 }
    1114           0 :                 return (0);
    1115             :         }
    1116           0 :         return (-1);
    1117             : }
    1118             : /* }}} */
    1119             : 
    1120             : /* {{{ proto string snmp2_get(string host, string community, string object_id [, int timeout [, int retries]]) 
    1121             :    Fetch a SNMP object */
    1122           0 : PHP_FUNCTION(snmp2_get)
    1123             : {
    1124           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_GET, SNMP_VERSION_2c);
    1125           0 : }
    1126             : /* }}} */
    1127             : 
    1128             : /* {{{ proto string snmp2_getnext(string host, string community, string object_id [, int timeout [, int retries]]) 
    1129             :    Fetch a SNMP object */
    1130           0 : PHP_FUNCTION(snmp2_getnext)
    1131             : {
    1132           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_GETNEXT, SNMP_VERSION_2c);
    1133           0 : }
    1134             : /* }}} */
    1135             : 
    1136             : /* {{{ proto array snmp2_walk(string host, string community, string object_id [, int timeout [, int retries]]) 
    1137             :    Return all objects under the specified object id */
    1138           0 : PHP_FUNCTION(snmp2_walk)
    1139             : {
    1140           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_WALK, SNMP_VERSION_2c);
    1141           0 : }
    1142             : /* }}} */
    1143             : 
    1144             : /* {{{ proto array snmp2_real_walk(string host, string community, string object_id [, int timeout [, int retries]])
    1145             :    Return all objects including their respective object id withing the specified one */
    1146           0 : PHP_FUNCTION(snmp2_real_walk)
    1147             : {
    1148           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_REALWALK, SNMP_VERSION_2c);
    1149           0 : }
    1150             : /* }}} */
    1151             : 
    1152             : /* {{{ proto int snmp2_set(string host, string community, string object_id, string type, mixed value [, int timeout [, int retries]]) 
    1153             :    Set the value of a SNMP object */
    1154           0 : PHP_FUNCTION(snmp2_set)
    1155             : {
    1156           0 :         php_snmp(INTERNAL_FUNCTION_PARAM_PASSTHRU,SNMP_CMD_SET, SNMP_VERSION_2c);
    1157           0 : }
    1158             : /* }}} */
    1159             : 
    1160             : /* {{{ proto void php_snmpv3(INTERNAL_FUNCTION_PARAMETERS, int st)
    1161             : *
    1162             : * Generic SNMPv3 object fetcher
    1163             : * From here is passed on the common internal object fetcher.
    1164             : *
    1165             : * st=SNMP_CMD_GET   snmp3_get() - query an agent and return a single value.
    1166             : * st=SNMP_CMD_GETNEXT   snmp3_getnext() - query an agent and return the next single value.
    1167             : * st=SNMP_CMD_WALK   snmp3_walk() - walk the mib and return a single dimensional array 
    1168             : *                       containing the values.
    1169             : * st=SNMP_CMD_REALWALK   snmp3_real_walk() - walk the mib and return an 
    1170             : *                            array of oid,value pairs.
    1171             : * st=SNMP_CMD_SET  snmp3_set() - query an agent and set a single value
    1172             : *
    1173             : */
    1174           0 : static void php_snmpv3(INTERNAL_FUNCTION_PARAMETERS, int st)
    1175             : {
    1176             :         char *a1, *a2, *a3, *a4, *a5, *a6, *a7, *a8;
    1177             :         int a1_len, a2_len, a3_len, a4_len, a5_len, a6_len, a7_len, a8_len;
    1178             :         struct snmp_session session;
    1179           0 :         long timeout = SNMP_DEFAULT_TIMEOUT;
    1180           0 :         long retries = SNMP_DEFAULT_RETRIES;
    1181           0 :         char type = (char) 0;
    1182           0 :         char *value = (char *) 0, *stype = "";
    1183             :         int stype_len, value_len;       
    1184             :         char hostname[MAX_NAME_LEN];
    1185           0 :         int remote_port = 161;
    1186             :         char *pptr;
    1187           0 :         int argc = ZEND_NUM_ARGS();
    1188             :         
    1189           0 :         if (st == SNMP_CMD_SET) {       
    1190           0 :                 if (zend_parse_parameters(argc TSRMLS_CC, "ssssssssss|ll", &a1, &a1_len, &a2, &a2_len, &a3, &a3_len,
    1191             :                         &a4, &a4_len, &a5, &a5_len, &a6, &a6_len, &a7, &a7_len, &a8, &a8_len, &stype, &stype_len, &value, &value_len, &timeout, &retries) == FAILURE) {
    1192           0 :                         return;
    1193             :                 }
    1194             :         } else {
    1195             :                 /* SNMP_CMD_GET
    1196             :                  * SNMP_CMD_GETNEXT
    1197             :                  * SNMP_CMD_WALK
    1198             :                  * SNMP_CMD_REALWALK
    1199             :                  */
    1200           0 :                 if (zend_parse_parameters(argc TSRMLS_CC, "ssssssss|ll", &a1, &a1_len, &a2, &a2_len, &a3, &a3_len,
    1201             :                         &a4, &a4_len, &a5, &a5_len, &a6, &a6_len, &a7, &a7_len, &a8, &a8_len, &timeout, &retries) == FAILURE) {
    1202           0 :                         return;
    1203             :                 }
    1204             :         }
    1205             : 
    1206           0 :         snmp_sess_init(&session);
    1207             :         /* This is all SNMPv3 */
    1208           0 :         session.version = SNMP_VERSION_3;
    1209             : 
    1210             :         /* Reading the hostname and its optional non-default port number */
    1211           0 :         strlcpy(hostname, a1, sizeof(hostname));
    1212           0 :         if ((pptr = strchr(hostname, ':'))) {
    1213           0 :                 remote_port = strtol(pptr + 1, NULL, 0);
    1214             :         }
    1215           0 :         session.peername = hostname;
    1216           0 :         session.remote_port = remote_port;
    1217             : 
    1218             :         /* Setting the security name. */
    1219           0 :         if (netsnmp_session_set_sec_name(&session, a2)) {
    1220           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could net set security name: %s", a2);
    1221           0 :                 RETURN_FALSE;
    1222             :         }
    1223             : 
    1224             :         /* Setting the security level. */
    1225           0 :         if (netsnmp_session_set_sec_level(&session, a3 TSRMLS_CC)) {
    1226           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid security level: %s", a3);
    1227           0 :                 RETURN_FALSE;
    1228             :         }
    1229             : 
    1230             :         /* Setting the authentication protocol. */
    1231           0 :         if (netsnmp_session_set_auth_protocol(&session, a4 TSRMLS_CC)) {
    1232           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid authentication protocol: %s", a4);
    1233           0 :                 RETURN_FALSE;
    1234             :         }
    1235             : 
    1236             :         /* Setting the authentication passphrase. */
    1237           0 :         if (netsnmp_session_gen_auth_key(&session, a5 TSRMLS_CC)) {
    1238           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not generate key for authentication pass phrase: %s", a5);
    1239           0 :                 RETURN_FALSE;
    1240             :         }
    1241             : 
    1242             :         /* Setting the security protocol. */
    1243           0 :         if (netsnmp_session_set_sec_protocol(&session, a6 TSRMLS_CC) && a6_len) {
    1244           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid security protocol: %s", a6);
    1245           0 :                 RETURN_FALSE;
    1246             :         }
    1247             : 
    1248             :         /* Setting the security protocol passphrase. */
    1249           0 :         if (netsnmp_session_gen_sec_key(&session, a7 TSRMLS_CC) && a7_len) {
    1250           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not generate key for security pass phrase: %s", a7);
    1251           0 :                 RETURN_FALSE;
    1252             :         }
    1253             : 
    1254           0 :         if (st == SNMP_CMD_SET) {
    1255           0 :                 type = stype[0];
    1256             :         }
    1257             : 
    1258           0 :         session.retries = retries;
    1259           0 :         session.timeout = timeout;
    1260             : 
    1261           0 :         php_snmp_internal(INTERNAL_FUNCTION_PARAM_PASSTHRU, st, &session, a8, type, value);
    1262             : }
    1263             : /* }}} */
    1264             : 
    1265             : /* {{{ proto int snmp3_get(string host, string sec_name, string sec_level, string auth_protocol, string auth_passphrase, string priv_protocol, string priv_passphrase, string object_id [, int timeout [, int retries]])
    1266             :    Fetch the value of a SNMP object */
    1267           0 : PHP_FUNCTION(snmp3_get)
    1268             : {
    1269           0 :         php_snmpv3(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_GET);
    1270           0 : }
    1271             : /* }}} */
    1272             : 
    1273             : /* {{{ proto int snmp3_getnext(string host, string sec_name, string sec_level, string auth_protocol, string auth_passphrase, string priv_protocol, string priv_passphrase, string object_id [, int timeout [, int retries]])
    1274             :    Fetch the value of a SNMP object */
    1275           0 : PHP_FUNCTION(snmp3_getnext)
    1276             : {
    1277           0 :         php_snmpv3(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_GETNEXT);
    1278           0 : }
    1279             : /* }}} */
    1280             : 
    1281             : /* {{{ proto int snmp3_walk(string host, string sec_name, string sec_level, string auth_protocol, string auth_passphrase, string priv_protocol, string priv_passphrase, string object_id [, int timeout [, int retries]])
    1282             :    Fetch the value of a SNMP object */
    1283           0 : PHP_FUNCTION(snmp3_walk)
    1284             : {
    1285           0 :         php_snmpv3(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_WALK);
    1286           0 : }
    1287             : /* }}} */
    1288             : 
    1289             : /* {{{ proto int snmp3_real_walk(string host, string sec_name, string sec_level, string auth_protocol, string auth_passphrase, string priv_protocol, string priv_passphrase, string object_id [, int timeout [, int retries]])
    1290             :    Fetch the value of a SNMP object */
    1291           0 : PHP_FUNCTION(snmp3_real_walk)
    1292             : {
    1293           0 :         php_snmpv3(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_REALWALK);
    1294           0 : }
    1295             : /* }}} */
    1296             : 
    1297             : /* {{{ proto int snmp3_set(string host, string sec_name, string sec_level, string auth_protocol, string auth_passphrase, string priv_protocol, string priv_passphrase, string object_id, string type, mixed value [, int timeout [, int retries]])
    1298             :    Fetch the value of a SNMP object */
    1299           0 : PHP_FUNCTION(snmp3_set)
    1300             : {
    1301           0 :         php_snmpv3(INTERNAL_FUNCTION_PARAM_PASSTHRU, SNMP_CMD_SET);
    1302           0 : }
    1303             : /* }}} */
    1304             : 
    1305             : /* {{{ proto void snmp_set_valueretrieval(int method)
    1306             :    Specify the method how the SNMP values will be returned */
    1307           0 : PHP_FUNCTION(snmp_set_valueretrieval)
    1308             : {
    1309             :         long method;
    1310             : 
    1311           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &method) == FAILURE) {
    1312           0 :                 return;
    1313             :         }
    1314             : 
    1315           0 :         if ((method == SNMP_VALUE_LIBRARY) || (method == SNMP_VALUE_PLAIN) || (method == SNMP_VALUE_OBJECT)) {
    1316           0 :                 SNMP_G(valueretrieval) = method;
    1317             :         }
    1318             : }
    1319             : /* }}} */
    1320             : 
    1321             : /* {{{ proto int snmp_get_valueretrieval()
    1322             :    Return the method how the SNMP values will be returned */
    1323           0 : PHP_FUNCTION(snmp_get_valueretrieval)
    1324             : {
    1325           0 :         RETURN_LONG(SNMP_G(valueretrieval));
    1326             : }
    1327             : /* }}} */
    1328             : 
    1329             : /* {{{ proto int snmp_read_mib(string filename)
    1330             :    Reads and parses a MIB file into the active MIB tree. */
    1331           0 : PHP_FUNCTION(snmp_read_mib)
    1332             : {
    1333             :         char *filename;
    1334             :         int filename_len;
    1335             : 
    1336           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &filename, &filename_len) == FAILURE) {
    1337           0 :                 return;
    1338             :         }
    1339             : 
    1340             :         /* Prevent read_mib() from printing any errors. */
    1341           0 :         snmp_disable_stderrlog();
    1342             :         
    1343           0 :         if (!read_mib(filename)) {
    1344           0 :                 char *error = strerror(errno);
    1345           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while reading MIB file '%s': %s", filename, error);
    1346           0 :                 RETURN_FALSE;
    1347             :         }
    1348           0 :         RETURN_TRUE;
    1349             : }
    1350             : /* }}} */
    1351             : 
    1352             : #endif
    1353             : 
    1354             : /*
    1355             :  * Local variables:
    1356             :  * tab-width: 4
    1357             :  * c-basic-offset: 4
    1358             :  * End:
    1359             :  * vim600: sw=4 ts=4 fdm=marker
    1360             :  * vim<600: sw=4 ts=4
    1361             :  */

Generated by: LCOV version 1.10

Generated at Sun, 13 Jul 2014 23:57:56 +0000 (9 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.