agent__handler_8c-source.html from net-snmp at Krugle

Show agent__handler_8c-source.html syntax highlighted

<!--#set var="section" value="development" -->
<!--#include virtual="/page-top.html" -->
<!-- CONTENT START -->
  <!-- Generated by Doxygen 1.3.9.1 -->

  <div class="qindex">
    <a class="qindex" href="index.html">Main&nbsp;Page</a> | <a class="qindex" href="modules.html">Modules</a> | <a class=
    "qindex" href="annotated.html">Data&nbsp;Structures</a> | <a class="qindex" href="files.html">File&nbsp;List</a> | <a class=
    "qindex" href="functions.html">Data&nbsp;Fields</a> | <a class="qindex" href="pages.html">Related&nbsp;Pages</a> | <a class=
    "qindex" href="examples.html">Examples</a>
  </div>

  <div class="nav">
    <a class="el" href="dir_000003.html">agent</a>
  </div>

  <h1>agent_handler.c</h1>

  <div class="fragment">
    <pre class="fragment">
00001 <span class="comment">/* Portions of this file are subject to the following copyright(s).  See</span>
00002 <span class="comment"> * the Net-SNMP's COPYING file for more details and other copyrights</span>
00003 <span class="comment"> * that may apply:</span>
00004 <span class="comment"> */</span>
00005 <span class="comment">/*</span>
00006 <span class="comment"> * Portions of this file are copyrighted by:</span>
00007 <span class="comment"> * Copyright &copy; 2003 Sun Microsystems, Inc. All rights reserved.</span>
00008 <span class="comment"> * Use is subject to license terms specified in the COPYING file</span>
00009 <span class="comment"> * distributed with the Net-SNMP package.</span>
00010 <span class="comment"> */</span>
00011 <span class="preprocessor">#include &lt;net-snmp/net-snmp-config.h&gt;</span>
00012 
00013 <span class="preprocessor">#include &lt;sys/types.h&gt;</span>
00014 
00015 <span class="preprocessor">#if HAVE_STRING_H</span>
00016 <span class="preprocessor">#include &lt;string.h&gt;</span>
00017 <span class="preprocessor">#endif</span>
00018 
00019 <span class="preprocessor">#include &lt;net-snmp/net-snmp-includes.h&gt;</span>
00020 <span class="preprocessor">#include &lt;net-snmp/agent/net-snmp-agent-includes.h&gt;</span>
00021 
00022 <span class="preprocessor">#include &lt;net-snmp/agent/bulk_to_next.h&gt;</span>
00023 
00024 
00025 <span class="keyword">static</span> <a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *_clone_handler(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *it);
00026 
00027 <span class="comment">/***********************************************************************/</span>
00028 <span class="comment">/*</span>
00029 <span class="comment"> * New Handler based API </span>
00030 <span class="comment"> */</span>
00031 <span class="comment">/***********************************************************************/</span>
00104 <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *
<a name="l00105" id="l00105"></a><a class="code" href="group__handler.html#ga7">00105</a> <a class="code" href=
"group__handler.html#ga7">netsnmp_create_handler</a>(<span class="keyword">const</span> <span class=
"keywordtype">char</span> *name,
00106                        Netsnmp_Node_Handler * handler_access_method)
00107 {
00108     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *ret = <a class="code" href=
"group__util.html#ga39">SNMP_MALLOC_TYPEDEF</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a>);
00109     <span class="keywordflow">if</span> (ret) {
00110         ret-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o3">access_method</a> = handler_access_method;
00111         <span class="keywordflow">if</span> (NULL != name) {
00112             ret-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a> = strdup(name);
00113             <span class="keywordflow">if</span> (NULL == ret-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>)
00114                 <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(ret);
00115         }
00116     }
00117     <span class="keywordflow">return</span> ret;
00118 }
00119 
00162 <a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *
<a name="l00163" id="l00163"></a><a class="code" href="group__handler.html#ga8">00163</a> <a class="code" href=
"group__handler.html#ga8">netsnmp_handler_registration_create</a>(<span class="keyword">const</span> <span class=
"keywordtype">char</span> *name,
00164                                     <a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler,
00165                                     oid * reg_oid, size_t reg_oid_len,
00166                                     <span class="keywordtype">int</span> modes)
00167 {
00168     <a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *the_reg;
00169     the_reg = <a class="code" href="group__util.html#ga39">SNMP_MALLOC_TYPEDEF</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a>);
00170     <span class="keywordflow">if</span> (!the_reg)
00171         <span class="keywordflow">return</span> NULL;
00172 
00173     <span class="keywordflow">if</span> (modes)
00174         the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o5">modes</a> = modes;
00175     <span class="keywordflow">else</span>
00176         the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o5">modes</a> = HANDLER_CAN_DEFAULT;
00177 
00178     the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o4">handler</a> = handler;
00179     the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o6">priority</a> = DEFAULT_MIB_PRIORITY;
00180     <span class="keywordflow">if</span> (name)
00181         the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o0">handlerName</a> = strdup(name);
00182     <a class="code" href="group__util.html#ga5">memdup</a>((u_char **) &amp; the_reg-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>, (<span class="keyword">const</span> u_char *) reg_oid,
00183            reg_oid_len * <span class="keyword">sizeof</span>(oid));
00184     the_reg-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o3">rootoid_len</a> = reg_oid_len;
00185     <span class="keywordflow">return</span> the_reg;
00186 }
00187 
00188 <a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *
00189 netsnmp_create_handler_registration(<span class="keyword">const</span> <span class="keywordtype">char</span> *name,
00190                                     Netsnmp_Node_Handler *
00191                                     handler_access_method, oid * reg_oid,
00192                                     size_t reg_oid_len, <span class="keywordtype">int</span> modes)
00193 {
00194     <span class="keywordflow">return</span>
00195         <a class="code" href="group__handler.html#ga8">netsnmp_handler_registration_create</a>(name,
00196                                             <a class="code" href=
"group__handler.html#ga7">netsnmp_create_handler</a>(name, handler_access_method),
00197                                             reg_oid, reg_oid_len, modes);
00198 }
00199 
00201 <span class="keywordtype">int</span>
<a name="l00202" id="l00202"></a><a class="code" href="group__handler.html#ga10">00202</a> <a class="code" href=
"group__handler.html#ga10">netsnmp_register_handler</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo)
00203 {
00204     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler;
00205     <span class="keywordflow">if</span> (reginfo == NULL) {
00206         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_register_handler() called illegally\n"</span>);
00207         netsnmp_assert(reginfo != NULL);
00208         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00209     }
00210 
00211     DEBUGIF(<span class="stringliteral">"handler::register"</span>) {
00212         DEBUGMSGTL((<span class="stringliteral">"handler::register"</span>, <span class=
"stringliteral">"Registering %s ("</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a>));
00213         <span class="keywordflow">for</span> (handler = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>; handler; handler = handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00214             DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class=
"stringliteral">"::%s"</span>, handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00215         }
00216 
00217         DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class="stringliteral">") at "</span>));
00218         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a> &amp;&amp; reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>) {
00219             DEBUGMSGOIDRANGE((<span class="stringliteral">"handler::register"</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>,
00220                               reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>,
00221                               reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>));
00222         } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>) {
00223             DEBUGMSGOID((<span class="stringliteral">"handler::register"</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>,
00224                          reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>));
00225         } <span class="keywordflow">else</span> {
00226             DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class=
"stringliteral">"[null]"</span>));
00227         }
00228         DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class="stringliteral">"\n"</span>));
00229     }
00230 
00231     <span class="comment">/*</span>
00232 <span class="comment">     * don't let them register for absolutely nothing.  Probably a mistake </span>
00233 <span class="comment">     */</span>
00234     <span class="keywordflow">if</span> (0 == reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a>) {
00235         reginfo-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o5">modes</a> = HANDLER_CAN_DEFAULT;
00236         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_WARNING, <span class=
"stringliteral">"no registration modes specified for %s. "</span>
00237                  <span class="stringliteral">"Defaulting to 0x%x\n"</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a>);
00238     }
00239 
00240     <span class="comment">/*</span>
00241 <span class="comment">     * for handlers that can't GETBULK, force a conversion handler on them </span>
00242 <span class="comment">     */</span>
00243     <span class="keywordflow">if</span> (!(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a> &amp; HANDLER_CAN_GETBULK)) {
00244         <a class="code" href="group__handler.html#ga14">netsnmp_inject_handler</a>(reginfo,
00245                                <a class="code" href=
"group__bulk__to__next.html#ga0">netsnmp_get_bulk_to_next_handler</a>());
00246     }
00247 
00248     <span class="keywordflow">return</span> netsnmp_register_mib(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a>,
00249                                 NULL, 0, 0,
00250                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>,
00251                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o6">priority</a>,
00252                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>,
00253                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>, NULL,
00254                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o9">timeout</a>, 0,
00255                                 reginfo, 1);
00256 }
00257 
00259 <span class="keywordtype">int</span>
<a name="l00260" id="l00260"></a><a class="code" href="group__handler.html#ga11">00260</a> <a class="code" href=
"group__handler.html#ga11">netsnmp_unregister_handler</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo)
00261 {
00262     <span class="keywordflow">return</span> <a class="code" href=
"group__agent__registry.html#ga32">unregister_mib_context</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>,
00263                                   reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o6">priority</a>,
00264                                   reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>,
00265                                   reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a>);
00266 }
00267 
00269 <span class="keywordtype">int</span>
<a name="l00270" id="l00270"></a><a class="code" href="group__handler.html#ga12">00270</a> <a class="code" href=
"group__handler.html#ga12">netsnmp_register_handler_nocallback</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo)
00271 {
00272     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler;
00273     <span class="keywordflow">if</span> (reginfo == NULL) {
00274         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_register_handler_nocallback() called illegally\n"</span>);
00275         netsnmp_assert(reginfo != NULL);
00276         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00277     }
00278     DEBUGIF(<span class="stringliteral">"handler::register"</span>) {
00279         DEBUGMSGTL((<span class="stringliteral">"handler::register"</span>,
00280                     <span class="stringliteral">"Registering (with no callback) "</span>));
00281         <span class="keywordflow">for</span> (handler = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>; handler; handler = handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00282             DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class=
"stringliteral">"::%s"</span>, handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00283         }
00284 
00285         DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class="stringliteral">" at "</span>));
00286         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a> &amp;&amp; reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>) {
00287             DEBUGMSGOIDRANGE((<span class="stringliteral">"handler::register"</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>,
00288                               reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>,
00289                               reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>));
00290         } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>) {
00291             DEBUGMSGOID((<span class="stringliteral">"handler::register"</span>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>,
00292                          reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>));
00293         } <span class="keywordflow">else</span> {
00294             DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class=
"stringliteral">"[null]"</span>));
00295         }
00296         DEBUGMSG((<span class="stringliteral">"handler::register"</span>, <span class="stringliteral">"\n"</span>));
00297     }
00298 
00299     <span class="comment">/*</span>
00300 <span class="comment">     * don't let them register for absolutely nothing.  Probably a mistake </span>
00301 <span class="comment">     */</span>
00302     <span class="keywordflow">if</span> (0 == reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a>) {
00303         reginfo-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o5">modes</a> = HANDLER_CAN_DEFAULT;
00304     }
00305 
00306     <span class="keywordflow">return</span> netsnmp_register_mib(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>,
00307                                 NULL, 0, 0,
00308                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>,
00309                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o6">priority</a>,
00310                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>,
00311                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>, NULL,
00312                                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o9">timeout</a>, 0,
00313                                 reginfo, 0);
00314 }
00315 
00321 <span class="keywordtype">int</span>
<a name="l00322" id="l00322"></a><a class="code" href="group__handler.html#ga13">00322</a> <a class="code" href=
"group__handler.html#ga13">netsnmp_inject_handler_before</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00323                               <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler,
00324                               <span class="keyword">const</span> <span class="keywordtype">char</span> *before_what)
00325 {
00326     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler2 = handler;
00327 
00328     <span class="keywordflow">if</span> (handler == NULL || reginfo == NULL) {
00329         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_inject_handler() called illegally\n"</span>);
00330         netsnmp_assert(reginfo != NULL);
00331         netsnmp_assert(handler != NULL);
00332         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00333     }
00334     <span class="keywordflow">while</span> (handler2-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00335         handler2 = handler2-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a>;  <span class=
"comment">/* Find the end of a handler sub-chain */</span>
00336     }
00337     <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a> == NULL) {
00338         DEBUGMSGTL((<span class="stringliteral">"handler:inject"</span>, <span class=
"stringliteral">"injecting %s\n"</span>, handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00339     }
00340     <span class="keywordflow">else</span> {
00341         DEBUGMSGTL((<span class="stringliteral">"handler:inject"</span>, <span class=
"stringliteral">"injecting %s before %s\n"</span>,
00342                     handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>, reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00343     }
00344     <span class="keywordflow">if</span> (before_what) {
00345         <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *nexth, *prevh = NULL;
00346         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a> == NULL) {
00347             <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"no handler to inject before\n"</span>);
00348             <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00349         }
00350         <span class="keywordflow">for</span>(nexth = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>; nexth;
00351             prevh = nexth, nexth = nexth-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a>) {
00352             <span class="keywordflow">if</span> (strcmp(nexth-&gt;handler_name, before_what) == 0)
00353                 <span class="keywordflow">break</span>;
00354         }
00355         <span class="keywordflow">if</span> (!nexth)
00356             <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00357         <span class="keywordflow">if</span> (prevh) {
00358             <span class="comment">/* after prevh and before nexth */</span>
00359             prevh-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a> = handler;
00360             handler2-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a> = nexth;
00361             handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o5">prev</a> = prevh;
00362             nexth-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o5">prev</a> = handler2;
00363             <span class="keywordflow">return</span> SNMPERR_SUCCESS;
00364         }
00365         <span class="comment">/* else we're first, which is what we do next anyway so fall through */</span>
00366     }
00367     handler2-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a> = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>;
00368     <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>)
00369         reginfo-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o4">handler</a>-&gt;<a class="code"
href="structnetsnmp__mib__handler__s.html#o5">prev</a> = handler2;
00370     reginfo-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o4">handler</a> = handler;
00371     <span class="keywordflow">return</span> SNMPERR_SUCCESS;
00372 }
00373 
00378 <span class="keywordtype">int</span>
<a name="l00379" id="l00379"></a><a class="code" href="group__handler.html#ga14">00379</a> <a class="code" href=
"group__handler.html#ga14">netsnmp_inject_handler</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00380                        <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler)
00381 {
00382     <span class="keywordflow">return</span> <a class="code" href=
"group__handler.html#ga13">netsnmp_inject_handler_before</a>(reginfo, handler, NULL);
00383 }
00384 
00386 NETSNMP_INLINE <span class="keywordtype">int</span>
<a name="l00387" id="l00387"></a><a class="code" href="group__handler.html#ga15">00387</a> <a class="code" href=
"group__handler.html#ga15">netsnmp_call_handler</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *next_handler,
00388                      <a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00389                      <a class="code" href=
"structnetsnmp__agent__request__info__s.html">netsnmp_agent_request_info</a> *reqinfo,
00390                      <a class="code" href="structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests)
00391 {
00392     Netsnmp_Node_Handler *nh;
00393     <span class="keywordtype">int</span>             ret;
00394 
00395     <span class="keywordflow">if</span> (next_handler == NULL || reginfo == NULL || reqinfo == NULL ||
00396         requests == NULL) {
00397         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_call_handler() called illegally\n"</span>);
00398         netsnmp_assert(next_handler != NULL);
00399         netsnmp_assert(reqinfo != NULL);
00400         netsnmp_assert(reginfo != NULL);
00401         netsnmp_assert(requests != NULL);
00402         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00403     }
00404 
00405     <span class="keywordflow">do</span> {
00406     nh = next_handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o3">access_method</a>;
00407     <span class="keywordflow">if</span> (!nh) {
00408         <span class="keywordflow">if</span> (next_handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00409             <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"no access method specified in handler %s."</span>,
00410                      next_handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a>);
00411             <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00412         }
00413         <span class="comment">/*</span>
00414 <span class="comment">         * The final handler registration in the chain may well not need</span>
00415 <span class="comment">         * to include a handler routine, if the processing of this object</span>
00416 <span class="comment">         * is handled completely by the agent toolkit helpers.</span>
00417 <span class="comment">         */</span>
00418         <span class="keywordflow">return</span> SNMP_ERR_NOERROR;
00419     }
00420 
00421     DEBUGMSGTL((<span class="stringliteral">"handler:calling"</span>, <span class=
"stringliteral">"calling handler %s for mode %s\n"</span>,
00422                 next_handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a>,
00423                 se_find_label_in_slist(<span class="stringliteral">"agent_mode"</span>, reqinfo-&gt;<a class="code" href=
"structnetsnmp__agent__request__info__s.html#o0">mode</a>)));
00424 
00425     <span class="comment">/*</span>
00426 <span class="comment">     * XXX: define acceptable return statuses </span>
00427 <span class="comment">     */</span>
00428     ret = (*nh) (next_handler, reginfo, reqinfo, requests);
00429 
00430     DEBUGMSGTL((<span class="stringliteral">"handler:returned"</span>, <span class=
"stringliteral">"handler %s returned %d\n"</span>,
00431                 next_handler-&gt;handler_name, ret));
00432 
00433     <span class="keywordflow">if</span> (! (next_handler-&gt;flags &amp; MIB_HANDLER_AUTO_NEXT))
00434         <span class="keywordflow">break</span>;
00435 
00436     <span class="comment">/*</span>
00437 <span class="comment">     * did handler signal that it didn't want auto next this time around?</span>
00438 <span class="comment">     */</span>
00439     <span class="keywordflow">if</span>(next_handler-&gt;flags &amp; MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE) {
00440         next_handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o2">flags</a> &amp;= ~MIB_HANDLER_AUTO_NEXT_OVERRIDE_ONCE;
00441         <span class="keywordflow">break</span>;
00442     }
00443 
00444     next_handler = next_handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a>;
00445 
00446     } <span class="keywordflow">while</span>(next_handler);
00447 
00448     <span class="keywordflow">return</span> ret;
00449 }
00450 
00454 <span class="keywordtype">int</span>
00455 netsnmp_call_handlers(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00456                       <a class="code" href=
"structnetsnmp__agent__request__info__s.html">netsnmp_agent_request_info</a> *reqinfo,
00457                       <a class="code" href="structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests)
00458 {
00459     <a class="code" href="structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request;
00460     <span class="keywordtype">int</span>             status;
00461 
00462     <span class="keywordflow">if</span> (reginfo == NULL || reqinfo == NULL || requests == NULL) {
00463         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_call_handlers() called illegally\n"</span>);
00464         netsnmp_assert(reqinfo != NULL);
00465         netsnmp_assert(reginfo != NULL);
00466         netsnmp_assert(requests != NULL);
00467         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00468     }
00469 
00470     <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a> == NULL) {
00471         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"no handler specified."</span>);
00472         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00473     }
00474 
00475     <span class="keywordflow">switch</span> (reqinfo-&gt;<a class="code" href=
"structnetsnmp__agent__request__info__s.html#o0">mode</a>) {
00476     <span class="keywordflow">case</span> MODE_GETBULK:
00477     <span class="keywordflow">case</span> MODE_GET:
00478     <span class="keywordflow">case</span> MODE_GETNEXT:
00479         <span class="keywordflow">if</span> (!(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a> &amp; HANDLER_CAN_GETANDGETNEXT))
00480             <span class="keywordflow">return</span> SNMP_ERR_NOERROR;    <span class="comment">/* legal */</span>
00481         <span class="keywordflow">break</span>;
00482 
00483     <span class="keywordflow">case</span> MODE_SET_RESERVE1:
00484     <span class="keywordflow">case</span> MODE_SET_RESERVE2:
00485     <span class="keywordflow">case</span> MODE_SET_ACTION:
00486     <span class="keywordflow">case</span> MODE_SET_COMMIT:
00487     <span class="keywordflow">case</span> MODE_SET_FREE:
00488     <span class="keywordflow">case</span> MODE_SET_UNDO:
00489         <span class="keywordflow">if</span> (!(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o5">modes</a> &amp; HANDLER_CAN_SET)) {
00490             <span class="keywordflow">for</span> (; requests; requests = requests-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o13">next</a>) {
00491                 <a class="code" href="group__snmp__agent.html#ga83">netsnmp_set_request_error</a>(reqinfo, requests,
00492                                           SNMP_ERR_NOTWRITABLE);
00493             }
00494             <span class="keywordflow">return</span> SNMP_ERR_NOERROR;
00495         }
00496         <span class="keywordflow">break</span>;
00497 
00498     <span class="keywordflow">default</span>:
00499         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"unknown mode in netsnmp_call_handlers! bug!\n"</span>);
00500         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00501     }
00502     DEBUGMSGTL((<span class="stringliteral">"handler:calling"</span>, <span class=
"stringliteral">"main handler %s\n"</span>,
00503                 reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00504 
00505     <span class="keywordflow">for</span> (request = requests ; request; request = request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o13">next</a>) {
00506         request-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o6">processed</a> = 0;
00507     }
00508 
00509     status = <a class="code" href="group__handler.html#ga15">netsnmp_call_handler</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>, reginfo, reqinfo, requests);
00510 
00511     <span class="keywordflow">return</span> status;
00512 }
00513 
00516 NETSNMP_INLINE <span class="keywordtype">int</span>
<a name="l00517" id="l00517"></a><a class="code" href="group__handler.html#ga17">00517</a> <a class="code" href=
"group__handler.html#ga17">netsnmp_call_next_handler</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *current,
00518                           <a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00519                           <a class="code" href=
"structnetsnmp__agent__request__info__s.html">netsnmp_agent_request_info</a> *reqinfo,
00520                           <a class="code" href="structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests)
00521 {
00522 
00523     <span class="keywordflow">if</span> (current == NULL || reginfo == NULL || reqinfo == NULL ||
00524         requests == NULL) {
00525         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_call_next_handler() called illegally\n"</span>);
00526         netsnmp_assert(current != NULL);
00527         netsnmp_assert(reginfo != NULL);
00528         netsnmp_assert(reqinfo != NULL);
00529         netsnmp_assert(requests != NULL);
00530         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00531     }
00532 
00533     <span class="keywordflow">return</span> <a class="code" href=
"group__handler.html#ga15">netsnmp_call_handler</a>(current-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>, reginfo, reqinfo, requests);
00534 }
00535 
00538 NETSNMP_INLINE <span class="keywordtype">int</span>
<a name="l00539" id="l00539"></a><a class="code" href="group__handler.html#ga18">00539</a> <a class="code" href=
"group__handler.html#ga18">netsnmp_call_next_handler_one_request</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *current,
00540                                       <a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00541                                       <a class="code" href=
"structnetsnmp__agent__request__info__s.html">netsnmp_agent_request_info</a> *reqinfo,
00542                                       <a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests)
00543 {
00544     <a class="code" href="structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request;
00545     <span class="keywordtype">int</span> ret;
00546     
00547     <span class="keywordflow">if</span> (!requests) {
00548         <a class="code" href="group__snmp__logging.html#ga41">snmp_log</a>(LOG_ERR, <span class=
"stringliteral">"netsnmp_call_next_handler_ONE_REQUEST() called illegally\n"</span>);
00549         netsnmp_assert(requests != NULL);
00550         <span class="keywordflow">return</span> SNMP_ERR_GENERR;
00551     }
00552 
00553     request = requests-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o13">next</a>;
00554     requests-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o13">next</a> = NULL;
00555     ret = <a class="code" href="group__handler.html#ga15">netsnmp_call_handler</a>(current-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>, reginfo, reqinfo, requests);
00556     requests-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o13">next</a> = request;
00557     <span class="keywordflow">return</span> ret;
00558 }
00559 
00561 <span class="keywordtype">void</span>
<a name="l00562" id="l00562"></a><a class="code" href="group__handler.html#ga19">00562</a> <a class="code" href=
"group__handler.html#ga19">netsnmp_handler_free</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler)
00563 {
00564     <span class="keywordflow">if</span> (handler != NULL) {
00565         <span class="keywordflow">if</span> (handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a> != NULL) {
00567             netsnmp_assert(handler != handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>); <span class="comment">/* bugs caught: 1 */</span>
00568             <a class="code" href="group__handler.html#ga19">netsnmp_handler_free</a>(handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>);
00569             handler-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a> = NULL;
00570         }
00575         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>);
00576         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(handler);
00577     }
00578 }
00579 
00583 <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *
<a name="l00584" id="l00584"></a><a class="code" href="group__handler.html#ga20">00584</a> <a class="code" href=
"group__handler.html#ga20">netsnmp_handler_dup</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler)
00585 {
00586     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *h = NULL;
00587 
00588     <span class="keywordflow">if</span> (handler == NULL) {
00589         <span class="keywordflow">return</span> NULL;
00590     }
00591 
00592     h = _clone_handler(handler);
00593 
00594     <span class="keywordflow">if</span> (h != NULL) {
00595         h-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o1">myvoid</a> = handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o1">myvoid</a>;
00596 
00597         <span class="keywordflow">if</span> (handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a> != NULL) {
00598             h-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a> = <a class="code" href=
"group__handler.html#ga20">netsnmp_handler_dup</a>(handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>);
00599             <span class="keywordflow">if</span> (h-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a> == NULL) {
00600                 <a class="code" href="group__handler.html#ga19">netsnmp_handler_free</a>(h);
00601                 <span class="keywordflow">return</span> NULL;
00602             }
00603             h-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o4">next</a>-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o5">prev</a> = h;
00604         }
00605         h-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o5">prev</a> = NULL;
00606         <span class="keywordflow">return</span> h;
00607     }
00608     <span class="keywordflow">return</span> NULL;
00609 }
00610 
00612 <span class="keywordtype">void</span>
<a name="l00613" id="l00613"></a><a class="code" href="group__handler.html#ga21">00613</a> <a class="code" href=
"group__handler.html#ga21">netsnmp_handler_registration_free</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo)
00614 {
00615     <span class="keywordflow">if</span> (reginfo != NULL) {
00616         <a class="code" href="group__handler.html#ga19">netsnmp_handler_free</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>);
00617         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a>);
00618         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a>);
00619         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>);
00620         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(reginfo);
00621     }
00622 }
00623 
00625 <a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *
<a name="l00626" id="l00626"></a><a class="code" href="group__handler.html#ga22">00626</a> <a class="code" href=
"group__handler.html#ga22">netsnmp_handler_registration_dup</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo)
00627 {
00628     <a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *r = NULL;
00629 
00630     <span class="keywordflow">if</span> (reginfo == NULL) {
00631         <span class="keywordflow">return</span> NULL;
00632     }
00633 
00634 
00635     r = (<a class="code" href="structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *) calloc(1,
00636                                                 <span class="keyword">sizeof</span>
00637                                                 (<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a>));
00638 
00639     <span class="keywordflow">if</span> (r != NULL) {
00640         r-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o5">modes</a> = reginfo-&gt;<a class=
"code" href="structnetsnmp__handler__registration__s.html#o5">modes</a>;
00641         r-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o6">priority</a> = reginfo-&gt;<a class=
"code" href="structnetsnmp__handler__registration__s.html#o6">priority</a>;
00642         r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a> = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o7">range_subid</a>;
00643         r-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o9">timeout</a> = reginfo-&gt;<a class=
"code" href="structnetsnmp__handler__registration__s.html#o9">timeout</a>;
00644         r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a> = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o8">range_ubound</a>;
00645         r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a> = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a>;
00646 
00647         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a> != NULL) {
00648             r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a> = strdup(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a>);
00649             <span class="keywordflow">if</span> (r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o0">handlerName</a> == NULL) {
00650                 <a class="code" href="group__handler.html#ga21">netsnmp_handler_registration_free</a>(r);
00651                 <span class="keywordflow">return</span> NULL;
00652             }
00653         }
00654 
00655         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a> != NULL) {
00656             r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a> = strdup(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a>);
00657             <span class="keywordflow">if</span> (r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o1">contextName</a> == NULL) {
00658                 <a class="code" href="group__handler.html#ga21">netsnmp_handler_registration_free</a>(r);
00659                 <span class="keywordflow">return</span> NULL;
00660             }
00661         }
00662 
00663         <span class="keywordflow">if</span> (reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a> != NULL) {
00664             <a class="code" href="group__util.html#ga5">memdup</a>((u_char **) &amp; (r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>),
00665                    (<span class="keyword">const</span> u_char *) reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a>,
00666                    reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o3">rootoid_len</a> * <span class="keyword">sizeof</span>(oid));
00667             <span class="keywordflow">if</span> (r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o2">rootoid</a> == NULL) {
00668                 <a class="code" href="group__handler.html#ga21">netsnmp_handler_registration_free</a>(r);
00669                 <span class="keywordflow">return</span> NULL;
00670             }
00671         }
00672 
00673         r-&gt;<a class="code" href="structnetsnmp__handler__registration__s.html#o4">handler</a> = <a class="code" href=
"group__handler.html#ga20">netsnmp_handler_dup</a>(reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>);
00674         <span class="keywordflow">if</span> (r-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a> == NULL) {
00675             <a class="code" href="group__handler.html#ga21">netsnmp_handler_registration_free</a>(r);
00676             <span class="keywordflow">return</span> NULL;
00677         }
00678         <span class="keywordflow">return</span> r;
00679     }
00680 
00681     <span class="keywordflow">return</span> NULL;
00682 }
00683 
00687 NETSNMP_INLINE netsnmp_delegated_cache *
<a name="l00688" id="l00688"></a><a class="code" href="group__handler.html#ga23">00688</a> <a class="code" href=
"group__handler.html#ga23">netsnmp_create_delegated_cache</a>(<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler,
00689                                <a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00690                                <a class="code" href=
"structnetsnmp__agent__request__info__s.html">netsnmp_agent_request_info</a> *reqinfo,
00691                                <a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests,
00692                                <span class="keywordtype">void</span> *localinfo)
00693 {
00694     netsnmp_delegated_cache *ret;
00695 
00696     ret = <a class="code" href="group__util.html#ga39">SNMP_MALLOC_TYPEDEF</a>(netsnmp_delegated_cache);
00697     <span class="keywordflow">if</span> (ret) {
00698         ret-&gt;transaction_id = reqinfo-&gt;<a class="code" href=
"structnetsnmp__agent__request__info__s.html#o1">asp</a>-&gt;pdu-&gt;transid;
00699         ret-&gt;handler = handler;
00700         ret-&gt;reginfo = reginfo;
00701         ret-&gt;reqinfo = reqinfo;
00702         ret-&gt;requests = requests;
00703         ret-&gt;localinfo = localinfo;
00704     }
00705     <span class="keywordflow">return</span> ret;
00706 }
00707 
00711 NETSNMP_INLINE netsnmp_delegated_cache *
<a name="l00712" id="l00712"></a><a class="code" href="group__handler.html#ga24">00712</a> <a class="code" href=
"group__handler.html#ga24">netsnmp_handler_check_cache</a>(netsnmp_delegated_cache *dcache)
00713 {
00714     <span class="keywordflow">if</span> (!dcache)
00715         <span class="keywordflow">return</span> dcache;
00716 
00717     <span class="keywordflow">if</span> (<a class="code" href=
"group__snmp__agent.html#ga68">netsnmp_check_transaction_id</a>(dcache-&gt;transaction_id) ==
00718         SNMPERR_SUCCESS)
00719         <span class="keywordflow">return</span> dcache;
00720 
00721     <span class="keywordflow">return</span> NULL;
00722 }
00723 
00725 NETSNMP_INLINE <span class="keywordtype">void</span>
<a name="l00726" id="l00726"></a><a class="code" href="group__handler.html#ga25">00726</a> <a class="code" href=
"group__handler.html#ga25">netsnmp_free_delegated_cache</a>(netsnmp_delegated_cache *dcache)
00727 {
00728     <span class="comment">/*</span>
00729 <span class="comment">     * right now, no extra data is there that needs to be freed </span>
00730 <span class="comment">     */</span>
00731     <span class="keywordflow">if</span> (dcache)
00732         <a class="code" href="group__util.html#ga36">SNMP_FREE</a>(dcache);
00733 
00734     <span class="keywordflow">return</span>;
00735 }
00736 
00737 
00739 <span class="keywordtype">void</span>
<a name="l00740" id="l00740"></a><a class="code" href="group__handler.html#ga26">00740</a> <a class="code" href=
"group__handler.html#ga26">netsnmp_handler_mark_requests_as_delegated</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *requests,
00741                                            <span class="keywordtype">int</span> isdelegated)
00742 {
00743     <span class="keywordflow">while</span> (requests) {
00744         requests-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o5">delegated</a> = isdelegated;
00745         requests = requests-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o13">next</a>;
00746     }
00747 }
00748 
00759 NETSNMP_INLINE <span class="keywordtype">void</span>
<a name="l00760" id="l00760"></a><a class="code" href="group__handler.html#ga27">00760</a> <a class="code" href=
"group__handler.html#ga27">netsnmp_request_add_list_data</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request,
00761                               <a class="code" href="structnetsnmp__data__list__s.html">netsnmp_data_list</a> *node)
00762 {
00763     <span class="keywordflow">if</span> (request) {
00764         <span class="keywordflow">if</span> (request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>)
00765             <a class="code" href="group__data__list.html#ga4">netsnmp_add_list_data</a>(&amp;request-&gt;<a class="code"
href="structnetsnmp__request__info__s.html#o1">parent_data</a>, node);
00766         <span class="keywordflow">else</span>
00767             request-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o1">parent_data</a> = node;
00768     }
00769 }
00770 
00780 NETSNMP_INLINE <span class="keywordtype">int</span>
<a name="l00781" id="l00781"></a><a class="code" href="group__handler.html#ga28">00781</a> <a class="code" href=
"group__handler.html#ga28">netsnmp_request_remove_list_data</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request,
00782                                  <span class="keyword">const</span> <span class="keywordtype">char</span> *name)
00783 {
00784     <span class="keywordflow">if</span> ((NULL == request) || (NULL ==request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>))
00785         <span class="keywordflow">return</span> 1;
00786 
00787     <span class="keywordflow">return</span> <a class="code" href=
"group__data__list.html#ga9">netsnmp_remove_list_node</a>(&amp;request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>, name);
00788 }
00789 
00801 NETSNMP_INLINE <span class="keywordtype">void</span>    *
<a name="l00802" id="l00802"></a><a class="code" href="group__handler.html#ga29">00802</a> <a class="code" href=
"group__handler.html#ga29">netsnmp_request_get_list_data</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request,
00803                               <span class="keyword">const</span> <span class="keywordtype">char</span> *name)
00804 {
00805     <span class="keywordflow">if</span> (request)
00806         <span class="keywordflow">return</span> <a class="code" href=
"group__data__list.html#ga7">netsnmp_get_list_data</a>(request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>, name);
00807     <span class="keywordflow">return</span> NULL;
00808 }
00809 
00811 NETSNMP_INLINE <span class="keywordtype">void</span>
<a name="l00812" id="l00812"></a><a class="code" href="group__handler.html#ga30">00812</a> <a class="code" href=
"group__handler.html#ga30">netsnmp_free_request_data_set</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request)
00813 {
00814     <span class="keywordflow">if</span> (request)
00815         <a class="code" href="group__data__list.html#ga1">netsnmp_free_list_data</a>(request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>);
00816 }
00817 
00819 NETSNMP_INLINE <span class="keywordtype">void</span>
<a name="l00820" id="l00820"></a><a class="code" href="group__handler.html#ga31">00820</a> <a class="code" href=
"group__handler.html#ga31">netsnmp_free_request_data_sets</a>(<a class="code" href=
"structnetsnmp__request__info__s.html">netsnmp_request_info</a> *request)
00821 {
00822     <span class="keywordflow">if</span> (request &amp;&amp; request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>) {
00823         <a class="code" href="group__data__list.html#ga2">netsnmp_free_all_list_data</a>(request-&gt;<a class="code" href=
"structnetsnmp__request__info__s.html#o1">parent_data</a>);
00824         request-&gt;<a class="code" href="structnetsnmp__request__info__s.html#o1">parent_data</a> = NULL;
00825     }
00826 }
00827 
00829 <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *
<a name="l00830" id="l00830"></a><a class="code" href="group__handler.html#ga32">00830</a> <a class="code" href=
"group__handler.html#ga32">netsnmp_find_handler_by_name</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00831                              <span class="keyword">const</span> <span class="keywordtype">char</span> *name)
00832 {
00833     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *it;
00834     <span class="keywordflow">for</span> (it = reginfo-&gt;<a class="code" href=
"structnetsnmp__handler__registration__s.html#o4">handler</a>; it; it = it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00835         <span class="keywordflow">if</span> (strcmp(it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>, name) == 0) {
00836             <span class="keywordflow">return</span> it;
00837         }
00838     }
00839     <span class="keywordflow">return</span> NULL;
00840 }
00841 
00846 <span class="keywordtype">void</span>           *
<a name="l00847" id="l00847"></a><a class="code" href="group__handler.html#ga33">00847</a> <a class="code" href=
"group__handler.html#ga33">netsnmp_find_handler_data_by_name</a>(<a class="code" href=
"structnetsnmp__handler__registration__s.html">netsnmp_handler_registration</a> *reginfo,
00848                                   <span class="keyword">const</span> <span class="keywordtype">char</span> *name)
00849 {
00850     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *it = <a class="code" href=
"group__handler.html#ga32">netsnmp_find_handler_by_name</a>(reginfo, name);
00851     <span class="keywordflow">if</span> (it)
00852         <span class="keywordflow">return</span> it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o1">myvoid</a>;
00853     <span class="keywordflow">return</span> NULL;
00854 }
00855 
00859 <span class="keyword">static</span> <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *
00860 _clone_handler(<a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *it)
00861 {
00862     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *dup;
00863 
00864     <span class="keywordflow">if</span>(NULL == it)
00865         <span class="keywordflow">return</span> NULL;
00866 
00867     dup = <a class="code" href="group__handler.html#ga7">netsnmp_create_handler</a>(it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>, it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o3">access_method</a>);
00868     <span class="keywordflow">if</span>(NULL != dup)
00869         dup-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o2">flags</a> = it-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o2">flags</a>;
00870 
00871     <span class="keywordflow">return</span> dup;
00872 }
00873 
00874 <span class="keyword">static</span> <a class="code" href=
"structnetsnmp__data__list__s.html">netsnmp_data_list</a> *handler_reg = NULL;
00875 
00876 <span class="keywordtype">void</span>
00877 handler_free_callback(<span class="keywordtype">void</span> *free)
00878 {
00879     <a class="code" href="group__handler.html#ga19">netsnmp_handler_free</a>((<a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *)free);
00880 }
00881 
00884 <span class="keywordtype">void</span>
<a name="l00885" id="l00885"></a><a class="code" href="group__handler.html#ga36">00885</a> <a class="code" href=
"group__handler.html#ga36">netsnmp_register_handler_by_name</a>(<span class="keyword">const</span> <span class=
"keywordtype">char</span> *name,
00886                                  <a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler)
00887 {
00888     <a class="code" href="group__data__list.html#ga4">netsnmp_add_list_data</a>(&amp;handler_reg,
00889                           <a class="code" href=
"group__data__list.html#ga3">netsnmp_create_data_list</a>(name, (<span class="keywordtype">void</span> *) handler,
00890                                                    handler_free_callback));
00891     DEBUGMSGTL((<span class="stringliteral">"handler_registry"</span>, <span class=
"stringliteral">"registering helper %s\n"</span>, name));
00892 }
00893 
00896 <span class="keywordtype">void</span>
<a name="l00897" id="l00897"></a><a class="code" href="group__handler.html#ga37">00897</a> <a class="code" href=
"group__handler.html#ga37">netsnmp_clear_handler_list</a>(<span class="keywordtype">void</span>)
00898 {
00899     DEBUGMSGTL((<span class="stringliteral">"agent_handler"</span>, <span class=
"stringliteral">"netsnmp_clear_handler_list() called\n"</span>));
00900     <a class="code" href="group__data__list.html#ga2">netsnmp_free_all_list_data</a>(handler_reg);
00901     handler_reg = NULL;
00902 }
00903 
00908 <span class="keywordtype">void</span>
00909 netsnmp_inject_handler_into_subtree(netsnmp_subtree *tp, <span class="keyword">const</span> <span class=
"keywordtype">char</span> *name,
00910                                     <a class="code" href=
"structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler,
00911                                     <span class="keyword">const</span> <span class="keywordtype">char</span> *before_what)
00912 {
00913     netsnmp_subtree *tptr;
00914     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *mh;
00915 
00916     <span class="keywordflow">for</span> (tptr = tp; tptr != NULL; tptr = tptr-&gt;next) {
00917         <span class="comment">/*  if (tptr-&gt;children) { </span>
00918 <span class="comment">              netsnmp_inject_handler_into_subtree(tptr-&gt;children,name,handler);</span>
00919 <span class="comment">            }   */</span>
00920         <span class="keywordflow">if</span> (strcmp(tptr-&gt;label_a, name) == 0) {
00921             DEBUGMSGTL((<span class="stringliteral">"injectHandler"</span>, <span class=
"stringliteral">"injecting handler %s into %s\n"</span>,
00922                         handler-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>, tptr-&gt;label_a));
00923             <a class="code" href=
"group__handler.html#ga13">netsnmp_inject_handler_before</a>(tptr-&gt;reginfo, _clone_handler(handler),
00924                                           before_what);
00925         } <span class="keywordflow">else</span> <span class="keywordflow">if</span> (tptr-&gt;reginfo != NULL &amp;&amp;
00926                    tptr-&gt;reginfo-&gt;handlerName != NULL &amp;&amp;
00927                    strcmp(tptr-&gt;reginfo-&gt;handlerName, name) == 0) {
00928             DEBUGMSGTL((<span class="stringliteral">"injectHandler"</span>, <span class=
"stringliteral">"injecting handler into %s/%s\n"</span>,
00929                         tptr-&gt;label_a, tptr-&gt;reginfo-&gt;handlerName));
00930             <a class="code" href=
"group__handler.html#ga13">netsnmp_inject_handler_before</a>(tptr-&gt;reginfo, _clone_handler(handler),
00931                                           before_what);
00932         } <span class="keywordflow">else</span> {
00933             <span class="keywordflow">for</span> (mh = tptr-&gt;reginfo-&gt;handler; mh != NULL; mh = mh-&gt;<a class=
"code" href="structnetsnmp__mib__handler__s.html#o4">next</a>) {
00934                 <span class="keywordflow">if</span> (mh-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a> &amp;&amp; strcmp(mh-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o0">handler_name</a>, name) == 0) {
00935                     DEBUGMSGTL((<span class="stringliteral">"injectHandler"</span>, <span class=
"stringliteral">"injecting handler into %s\n"</span>,
00936                                 tptr-&gt;label_a));
00937                     <a class="code" href="group__handler.html#ga13">netsnmp_inject_handler_before</a>(tptr-&gt;reginfo,
00938                                                   _clone_handler(handler),
00939                                                   before_what);
00940                     <span class="keywordflow">break</span>;
00941                 } <span class="keywordflow">else</span> {
00942                     DEBUGMSGTL((<span class="stringliteral">"yyyinjectHandler"</span>,
00943                                 <span class="stringliteral">"not injecting handler into %s\n"</span>,
00944                                 mh-&gt;<a class="code" href="structnetsnmp__mib__handler__s.html#o0">handler_name</a>));
00945                 }
00946             }
00947         }
00948     }
00949 }
00950 
00951 <span class="keyword">static</span> <span class="keywordtype">int</span>      doneit = 0;
00955 <span class="keywordtype">void</span>
00956 parse_injectHandler_conf(<span class="keyword">const</span> <span class="keywordtype">char</span> *token, <span class=
"keywordtype">char</span> *cptr)
00957 {
00958     <span class="keywordtype">char</span>            handler_to_insert[256], reg_name[256];
00959     subtree_context_cache *stc;
00960     <a class="code" href="structnetsnmp__mib__handler__s.html">netsnmp_mib_handler</a> *handler;
00961 
00962     <span class="comment">/*</span>
00963 <span class="comment">     * XXXWWW: ensure instead that handler isn't inserted twice </span>
00964 <span class="comment">     */</span>
00965     <span class="keywordflow">if</span> (doneit)                 <span class=
"comment">/* we only do this once without restart the agent */</span>
00966         <span class="keywordflow">return</span>;
00967 
00968     cptr = copy_nword(cptr, handler_to_insert, <span class="keyword">sizeof</span>(handler_to_insert));
00969     handler = <a class="code" href="group__data__list.html#ga7">netsnmp_get_list_data</a>(handler_reg, handler_to_insert);
00970     <span class="keywordflow">if</span> (!handler) {
00971         config_perror(<span class="stringliteral">"no such \"%s\" handler registered."</span>);
00972         <span class="keywordflow">return</span>;
00973     }
00974 
00975     <span class="keywordflow">if</span> (!cptr) {
00976         config_perror(<span class="stringliteral">"no INTONAME specified.  Can't do insertion."</span>);
00977         <span class="keywordflow">return</span>;
00978     }
00979     cptr = copy_nword(cptr, reg_name, <span class="keyword">sizeof</span>(reg_name));
00980 
00981     <span class="keywordflow">for</span> (stc = get_top_context_cache(); stc; stc = stc-&gt;<a class="code" href=
"structnetsnmp__mib__handler__s.html#o4">next</a>) {
00982         DEBUGMSGTL((<span class="stringliteral">"injectHandler"</span>, <span class=
"stringliteral">"Checking context tree %s (before=%s)\n"</span>,
00983                     stc-&gt;context_name, (cptr)?cptr:<span class="stringliteral">"null"</span>));
00984         netsnmp_inject_handler_into_subtree(stc-&gt;first_subtree, reg_name,
00985                                             handler, cptr);
00986     }
00987 }
00988 
00993 <span class="keyword">static</span> <span class="keywordtype">int</span>
00994 handler_mark_doneit(<span class="keywordtype">int</span> majorID, <span class="keywordtype">int</span> minorID,
00995                     <span class="keywordtype">void</span> *serverarg, <span class="keywordtype">void</span> *clientarg)
00996 {
00997     doneit = 1;
00998     <span class="keywordflow">return</span> 0;
00999 }
01000 
01004 <span class="keywordtype">void</span>
01005 netsnmp_init_handler_conf(<span class="keywordtype">void</span>)
01006 {
01007     snmpd_register_config_handler(<span class="stringliteral">"injectHandler"</span>,
01008                                   parse_injectHandler_conf,
01009                                   NULL, <span class=
"stringliteral">"injectHandler NAME INTONAME [BEFORE_OTHER_NAME]"</span>);
01010     <a class="code" href="group__callback.html#ga8">snmp_register_callback</a>(SNMP_CALLBACK_LIBRARY,
01011                            SNMP_CALLBACK_POST_READ_CONFIG,
01012                            handler_mark_doneit, NULL);
01013 
01014     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"GET"</span>), MODE_GET);
01015     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"GETNEXT"</span>), MODE_GETNEXT);
01016     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"GETBULK"</span>), MODE_GETBULK);
01017     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_BEGIN"</span>),
01018                          MODE_SET_BEGIN);
01019     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_RESERVE1"</span>),
01020                          MODE_SET_RESERVE1);
01021     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_RESERVE2"</span>),
01022                          MODE_SET_RESERVE2);
01023     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_ACTION"</span>),
01024                          MODE_SET_ACTION);
01025     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_COMMIT"</span>),
01026                          MODE_SET_COMMIT);
01027     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_FREE"</span>), MODE_SET_FREE);
01028     se_add_pair_to_slist(<span class="stringliteral">"agent_mode"</span>, strdup(<span class=
"stringliteral">"SET_UNDO"</span>), MODE_SET_UNDO);
01029 
01030     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"pre-request"</span>),
01031                          MODE_BSTEP_PRE_REQUEST);
01032     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"object_lookup"</span>),
01033                          MODE_BSTEP_OBJECT_LOOKUP);
01034     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"check_value"</span>),
01035                          MODE_BSTEP_CHECK_VALUE);
01036     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"row_create"</span>),
01037                          MODE_BSTEP_ROW_CREATE);
01038     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"undo_setup"</span>),
01039                          MODE_BSTEP_UNDO_SETUP);
01040     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"set_value"</span>),
01041                          MODE_BSTEP_SET_VALUE);
01042     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"check_consistency"</span>),
01043                          MODE_BSTEP_CHECK_CONSISTENCY);
01044     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"undo_set"</span>),
01045                          MODE_BSTEP_UNDO_SET);
01046     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"commit"</span>),
01047                          MODE_BSTEP_COMMIT);
01048     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"undo_commit"</span>),
01049                          MODE_BSTEP_UNDO_COMMIT);
01050     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"irreversible_commit"</span>),
01051                          MODE_BSTEP_IRREVERSIBLE_COMMIT);
01052     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"undo_cleanup"</span>),
01053                          MODE_BSTEP_UNDO_CLEANUP);
01054     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"post_request"</span>),
01055                          MODE_BSTEP_POST_REQUEST);
01056     se_add_pair_to_slist(<span class="stringliteral">"babystep_mode"</span>, strdup(<span class=
"stringliteral">"original"</span>), 0xffff);
01057 
01058     <span class="comment">/*</span>
01059 <span class="comment">     * xxx-rks: hmmm.. will this work for modes which are or'd together?</span>
01060 <span class="comment">     *          I'm betting not...</span>
01061 <span class="comment">     */</span>
01062     se_add_pair_to_slist(<span class="stringliteral">"handler_can_mode"</span>, strdup(<span class=
"stringliteral">"GET/GETNEXT"</span>),
01063                          HANDLER_CAN_GETANDGETNEXT);
01064     se_add_pair_to_slist(<span class="stringliteral">"handler_can_mode"</span>, strdup(<span class=
"stringliteral">"SET"</span>),
01065                          HANDLER_CAN_SET);
01066     se_add_pair_to_slist(<span class="stringliteral">"handler_can_mode"</span>, strdup(<span class=
"stringliteral">"GETBULK"</span>),
01067                          HANDLER_CAN_GETBULK);
01068     se_add_pair_to_slist(<span class="stringliteral">"handler_can_mode"</span>, strdup(<span class=
"stringliteral">"BABY_STEP"</span>),
01069                          HANDLER_CAN_BABY_STEP);
01070 }
01071 
</pre>
  </div>
  <hr size="1" />

  <address style="align: right;">
    <small>Generated on Fri Dec 30 13:47:43 2005 for net-snmp by&nbsp; <a href="http://www.doxygen.org/index.html"><img src=
    "doxygen.png" alt="doxygen" align="middle" border="0" /></a> 1.3.9.1</small>
  </address>
<!-- CONTENT END -->
<!--#include virtual="/page-bottom.html" -->
See more files for this project here