/*
 * Copyright (c) 2000, 2006, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package com.sun.jmx.snmp.agent;

import java.util.Vector;
import java.util.ArrayList;
import java.util.Hashtable;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Arrays;
import java.util.logging.Level;

import static com.sun.jmx.defaults.JmxProperties.SNMP_ADAPTOR_LOGGER;
import com.sun.jmx.snmp.SnmpVarBind;
import com.sun.jmx.snmp.SnmpStatusException;
import com.sun.jmx.snmp.SnmpDefinitions;
import com.sun.jmx.snmp.SnmpOid;
import com.sun.jmx.snmp.SnmpPdu;
import com.sun.jmx.snmp.SnmpEngine;

//  XXX: things to do: use SnmpOid rather than `instance' for future
//       evolutions.
//  XXX: Maybe use hashlists rather than vectors for entries?
//       => in that case, the key should be SnmpOid.toString()
//
/**
 * This class is used to register varbinds from a SNMP varbind list with
 * the SnmpMibNode responsible for handling the requests concerning that
 * varbind.
 * This class holds a hashtable of Handler nodes, whith the involved
 * SnmpMibNode as a key.
 * When the involved SnmpMibNode is a group, the sublist of varbind is
 * directly stored in the Handler node.
 * When the involved SnmpMibNode is a table, the sublist is stored in a
 * sorted array indexed by the OID of the entry involved.
 */
final class SnmpRequestTree {

    // Constructor:
    // @param  req The SnmpMibRequest that will be segmented in this
    //         tree. It holds the original varbind vector passed
    //         by the SnmpSubRequestHandler to this MIB. This
    //         varbind vector is used to retrieve the "real"
    //         position of a varbind in the vector. There is no other easy
    //         way to do this - since as a result of the segmentation the
    //         original positions will be lost.
    // @param  creationflag indicates whether the operation involved
    //         allows for entry creation (ie: it is a SET request).
    // @param  pdutype indicates the type of the request PDU as defined
    //         in SnmpDefinitions
    //
    SnmpRequestTree(SnmpMibRequest req, boolean creationflag, int pdutype) {
        this.request = req;
        this.version  = req.getVersion();
        this.creationflag = creationflag;
        this.hashtable = new Hashtable<Object, Handler>();
        setPduType(pdutype);
    }

    public static int mapSetException(int errorStatus, int version)
        throws SnmpStatusException {

        final int errorCode = errorStatus;

        if (version == SnmpDefinitions.snmpVersionOne)
            return errorCode;

        int mappedErrorCode = errorCode;

        // Now take care of V2 errorCodes that can be stored
        // in the varbind itself:
        if (errorCode == SnmpStatusException.noSuchObject)
            // noSuchObject => notWritable
            mappedErrorCode = SnmpStatusException.snmpRspNotWritable;

        else if (errorCode == SnmpStatusException.noSuchInstance)
            // noSuchInstance => notWritable
            mappedErrorCode = SnmpStatusException.snmpRspNotWritable;

        return mappedErrorCode;
    }

    public static int mapGetException(int errorStatus, int version)
        throws SnmpStatusException {

        final int errorCode = errorStatus;
        if (version == SnmpDefinitions.snmpVersionOne)
            return errorCode;

        int mappedErrorCode = errorCode;

        // Now take care of V2 errorCodes that can be stored
        // in the varbind itself:
        if (errorCode ==
            SnmpStatusException.noSuchObject)
            // noSuchObject => noSuchObject
            mappedErrorCode = errorCode;

        else if (errorCode ==
                 SnmpStatusException.noSuchInstance)
            // noSuchInstance => noSuchInstance
            mappedErrorCode = errorCode;

        // Now we're going to try to transform every other
        // global code in either noSuchInstance or noSuchObject,
        // so that the get can return a partial result.
        //
        // Only noSuchInstance or noSuchObject can be stored
        // in the varbind itself.
        //

        // According to RFC 1905: noAccess is emitted when the
        // the access is denied because it is not in the MIB view...
        //
        else if (errorCode ==
                 SnmpStatusException.noAccess)
            // noAccess => noSuchInstance
            mappedErrorCode = SnmpStatusException.noSuchInstance;

        // According to RFC 1905: (my interpretation because it is not
        // really clear) The specified variable name exists - but the
        // variable does not exists and cannot be created under the
        // present circumstances (probably because the request specifies
        // another variable/value which is incompatible, or because the
        // value of some other variable in the MIB prevents the creation)
        //
        // Note that this error should never be raised in a GET context
        // but who knows?
        //
        else if (errorCode == SnmpStatusException.snmpRspInconsistentName)
            // inconsistentName => noSuchInstance
            mappedErrorCode = SnmpStatusException.noSuchInstance;

        // All the errors comprised between snmpRspWrongType and
        // snmpRspInconsistentValue concern values: so we're going
        // to assume the OID was correct, and reply with noSuchInstance.
        //
        // Note that this error should never be raised in a GET context
        // but who knows?
        //
        else if ((errorCode >= SnmpStatusException.snmpRspWrongType) &&
                 (errorCode <= SnmpStatusException.snmpRspInconsistentValue))
            mappedErrorCode = SnmpStatusException.noSuchInstance;

        // We're going to assume the OID was correct, and reply
        // with noSuchInstance.
        //
        else if (errorCode == SnmpStatusException.readOnly)
            mappedErrorCode = SnmpStatusException.noSuchInstance;

        // For all other errors but genErr, we're going to reply with
        // noSuchObject
        //
        else if (errorCode != SnmpStatusException.snmpRspAuthorizationError &&
                 errorCode != SnmpStatusException.snmpRspGenErr)
            mappedErrorCode = SnmpStatusException.noSuchObject;

        // Only genErr will abort the GET and be returned as global
        // error.
        //
        return mappedErrorCode;

    }

    //-------------------------------------------------------------------
    // This class is a package implementation of the enumeration of
    // SnmSubRequest associated with an Handler node.
    //-------------------------------------------------------------------

    static final class Enum implements Enumeration {
        Enum(SnmpRequestTree hlist,Handler h) {
            handler = h;
            this.hlist = hlist;
            size = h.getSubReqCount();
        }
        private final Handler handler;
        private final SnmpRequestTree hlist;
        private int   entry = 0;
        private int   iter  = 0;
        private int   size  = 0;

        public boolean hasMoreElements() {
            return iter < size;
        }

        public Object nextElement() throws NoSuchElementException  {
            if (iter == 0) {
                if (handler.sublist != null) {
                    iter++;
                    return hlist.getSubRequest(handler);
                }
            }
            iter ++;
            if (iter > size) throw new NoSuchElementException();
            Object result = hlist.getSubRequest(handler,entry);
            entry++;
            return result;
        }
    }

    //-------------------------------------------------------------------
    // This class is a package implementation of the SnmpMibSubRequest
    // interface. It can only be instantiated by SnmpRequestTree.
    //-------------------------------------------------------------------

    static final class SnmpMibSubRequestImpl implements SnmpMibSubRequest {
        SnmpMibSubRequestImpl(SnmpMibRequest global, Vector<SnmpVarBind> sublist,
                           SnmpOid entryoid, boolean isnew,
                           boolean getnextflag, SnmpVarBind rs) {
            this.global = global;
            varbinds           = sublist;
            this.version       = global.getVersion();
            this.entryoid      = entryoid;
            this.isnew         = isnew;
            this.getnextflag   = getnextflag;
            this.statusvb      = rs;
        }

        final private Vector<SnmpVarBind> varbinds;
        final private SnmpMibRequest global;
        final private int            version;
        final private boolean        isnew;
        final private SnmpOid        entryoid;
        final private boolean        getnextflag;
        final private SnmpVarBind    statusvb;

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public Enumeration getElements() {
            return varbinds.elements();
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public Vector<SnmpVarBind> getSubList() {
            return varbinds;
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public final int getSize()  {
            if (varbinds == null) return 0;
            return varbinds.size();
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public void addVarBind(SnmpVarBind varbind) {
            // XXX not sure we must also add the varbind in the global
            //     request? or whether we should raise an exception:
            //     in principle, this method should not be called!
            varbinds.addElement(varbind);
            global.addVarBind(varbind);
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibSubRequest interface.
        // See SnmpMibSubRequest for the java doc.
        // -------------------------------------------------------------
        public boolean isNewEntry() {
            return isnew;
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibSubRequest interface.
        // See SnmpMibSubRequest for the java doc.
        // -------------------------------------------------------------
        public SnmpOid getEntryOid() {
            return entryoid;
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public int getVarIndex(SnmpVarBind varbind) {
            if (varbind == null) return 0;
            return global.getVarIndex(varbind);
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public Object getUserData() { return global.getUserData(); }


        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibSubRequest interface.
        // See SnmpMibSubRequest for the java doc.
        // -------------------------------------------------------------

        public void registerGetException(SnmpVarBind var,
                                         SnmpStatusException exception)
            throws SnmpStatusException {
            // The index in the exception must correspond to
            // the SNMP index ...
            //
            if (version == SnmpDefinitions.snmpVersionOne)
                throw new SnmpStatusException(exception, getVarIndex(var)+1);

            if (var == null)
                throw exception;

            // If we're doing a getnext ==> endOfMibView
            if (getnextflag) {
                var.value = SnmpVarBind.endOfMibView;
                return;
            }

            final int errorCode = mapGetException(exception.getStatus(),
                                                  version);

            // Now take care of V2 errorCodes that can be stored
            // in the varbind itself:
            if (errorCode ==
                SnmpStatusException.noSuchObject)
                // noSuchObject => noSuchObject
                var.value= SnmpVarBind.noSuchObject;

            else if (errorCode ==
                     SnmpStatusException.noSuchInstance)
                // noSuchInstance => noSuchInstance
                var.value= SnmpVarBind.noSuchInstance;

            else
                throw new SnmpStatusException(errorCode, getVarIndex(var)+1);

        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibSubRequest interface.
        // See SnmpMibSubRequest for the java doc.
        // -------------------------------------------------------------
        public void registerSetException(SnmpVarBind var,
                                         SnmpStatusException exception)
            throws SnmpStatusException {
            // The index in the exception must correspond to
            // the SNMP index ...
            //
            if (version == SnmpDefinitions.snmpVersionOne)
                throw new SnmpStatusException(exception, getVarIndex(var)+1);

            // Although the first pass of check() did not fail,
            // the set() phase could not be carried out correctly.
            // Since we don't know how to make an "undo", and some
            // assignation may already have been performed, we're going
            // to throw an snmpRspUndoFailed.
            //
            throw new SnmpStatusException(SnmpDefinitions.snmpRspUndoFailed,
                                          getVarIndex(var)+1);
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibSubRequest interface.
        // See SnmpMibSubRequest for the java doc.
        // -------------------------------------------------------------
        public void registerCheckException(SnmpVarBind var,
                                           SnmpStatusException exception)
            throws SnmpStatusException {
            // The index in the exception must correspond to
            // the SNMP index ...
            //
            // We throw the exception in order to abort the SET operation
            // in an atomic way.
            final int errorCode = exception.getStatus();
            final int mappedErrorCode = mapSetException(errorCode,
                                                        version);

            if (errorCode != mappedErrorCode)
                throw new
                    SnmpStatusException(mappedErrorCode, getVarIndex(var)+1);
            else
                throw new SnmpStatusException(exception, getVarIndex(var)+1);
        }

        // -------------------------------------------------------------
        // Implements the method defined in SnmpMibRequest interface.
        // See SnmpMibRequest for the java doc.
        // -------------------------------------------------------------
        public int getVersion() {
            return version;
        }

        public SnmpVarBind getRowStatusVarBind() {
            return statusvb;
        }

        public SnmpPdu getPdu() {
            return global.getPdu();
        }

        public int getRequestPduVersion() {
            return global.getRequestPduVersion();
        }

        public SnmpEngine getEngine() {
            return global.getEngine();
        }

        public String getPrincipal() {
            return global.getPrincipal();
        }

        public int getSecurityLevel() {
            return global.getSecurityLevel();
        }

        public int getSecurityModel() {
            return global.getSecurityModel();
        }

        public byte[] getContextName() {
            return global.getContextName();
        }

        public byte[] getAccessContextName() {
            return global.getAccessContextName();
        }
    }

    //-------------------------------------------------------------------
    // This class implements a node in the SnmpRequestTree.
    // It stores:
    //    o The SnmpMibNode involved (key)
    //    o The sublist of varbind directly handled by this node
    //    o A vector of sublists concerning the entries (existing or not)
    //      of the SnmpMIbNode (when it is a table).
    //-------------------------------------------------------------------

    static final class Handler {
        SnmpMibNode meta;       // The meta  which handles the sublist.
        int         depth;      // The depth of the meta node.
        Vector<SnmpVarBind> sublist; // The sublist of varbinds to be handled.
        // List        entryoids;  // Sorted array of entry oids
        // List        entrylists; // Sorted array of entry lists
        // List        isentrynew; // Sorted array of booleans
        SnmpOid[]     entryoids  = null; // Sorted array of entry oids
        Vector<SnmpVarBind>[] entrylists = null; // Sorted array of entry lists
        boolean[]     isentrynew = null; // Sorted array of booleans
        SnmpVarBind[] rowstatus  = null; // RowStatus varbind, if any
        int entrycount = 0;
        int entrysize  = 0;

        final int type; // request PDU type as defined in SnmpDefinitions
        final private static int Delta = 10;

        public Handler(int pduType) {
            this.type = pduType;
        }

        /**
         * Adds a varbind in this node sublist.
         */
        public void addVarbind(SnmpVarBind varbind) {
            if (sublist == null) sublist = new Vector<SnmpVarBind>();
            sublist.addElement(varbind);
        }

        /**
         * register an entry for the given oid at the given position with
         * the given sublist.
         */
        @SuppressWarnings("unchecked")
        // We need this because of new Vector[n] instead of
        // new Vector<SnmpVarBind>[n], which is illegal.
        void add(int pos,SnmpOid oid, Vector<SnmpVarBind> v, boolean isnew,
                 SnmpVarBind statusvb) {

            if (entryoids == null) {
                // Vectors are null: Allocate new vectors

                entryoids  = new SnmpOid[Delta];
                entrylists = new Vector[Delta];
                isentrynew = new boolean[Delta];
                rowstatus  = new SnmpVarBind[Delta];
                entrysize  = Delta;
                pos = 0;

            } else if (pos >= entrysize || entrycount == entrysize) {
                // Vectors must be enlarged

                // Save old vectors
                SnmpOid[]     olde = entryoids;
                Vector[]      oldl = entrylists;
                boolean[]     oldn = isentrynew;
                SnmpVarBind[] oldr = rowstatus;

                // Allocate larger vectors
                entrysize += Delta;
                entryoids =  new SnmpOid[entrysize];
                entrylists = new Vector[entrysize];
                isentrynew = new boolean[entrysize];
                rowstatus  = new SnmpVarBind[entrysize];

                // Check pos validity
                if (pos > entrycount) pos = entrycount;
                if (pos < 0) pos = 0;

                final int l1 = pos;
                final int l2 = entrycount - pos;

                // Copy original vectors up to `pos'
                if (l1 > 0) {
                    java.lang.System.arraycopy(olde,0,entryoids,
                                               0,l1);
                    java.lang.System.arraycopy(oldl,0,entrylists,
                                               0,l1);
                    java.lang.System.arraycopy(oldn,0,isentrynew,
                                               0,l1);
                    java.lang.System.arraycopy(oldr,0,rowstatus,
                                               0,l1);
                }

                // Copy original vectors from `pos' to end, leaving
                // an empty room at `pos' in the new vectors.
                if (l2 > 0) {
                    final int l3 = l1+1;
                    java.lang.System.arraycopy(olde,l1,entryoids,
                                               l3,l2);
                    java.lang.System.arraycopy(oldl,l1,entrylists,
                                               l3,l2);
                    java.lang.System.arraycopy(oldn,l1,isentrynew,
                                               l3,l2);
                    java.lang.System.arraycopy(oldr,l1,rowstatus,
                                               l3,l2);
                }


            } else if (pos < entrycount) {
                // Vectors are large enough to accomodate one additional
                // entry.
                //
                // Shift vectors, making an empty room at `pos'
                final int l1 = pos+1;
                final int l2 = entrycount - pos;

                java.lang.System.arraycopy(entryoids,pos,entryoids,
                                           l1,l2);
                java.lang.System.arraycopy(entrylists,pos,entrylists,
                                           l1,l2);
                java.lang.System.arraycopy(isentrynew,pos,isentrynew,
                                           l1,l2);
                java.lang.System.arraycopy(rowstatus,pos,rowstatus,
                                           l1,l2);
            }

            // Fill the gap at `pos'
            entryoids[pos]  = oid;
            entrylists[pos] = v;
            isentrynew[pos] = isnew;
            rowstatus[pos]  = statusvb;
            entrycount++;
        }

        public void addVarbind(SnmpVarBind varbind, SnmpOid entryoid,
                               boolean isnew, SnmpVarBind statusvb)
            throws SnmpStatusException {
            Vector<SnmpVarBind> v = null;
            SnmpVarBind rs = statusvb;

            if (entryoids == null) {
//              entryoids = new ArrayList();
//              entrylists = new ArrayList();
//              isentrynew = new ArrayList();
                v = new Vector<SnmpVarBind>();
//              entryoids.add(entryoid);
//              entrylists.add(v);
//              isentrynew.add(new Boolean(isnew));
                add(0,entryoid,v,isnew,rs);
            } else {
                // int pos = findOid(entryoids,entryoid);
                // int pos = findOid(entryoids,entrycount,entryoid);
                final int pos =
                    getInsertionPoint(entryoids,entrycount,entryoid);
                if (pos > -1 && pos < entrycount &&
                    entryoid.compareTo(entryoids[pos]) == 0) {
                    v  = entrylists[pos];
                    rs = rowstatus[pos];
                } else {
                    // if (pos == -1 || pos >= entryoids.size() ) {
                    // if (pos == -1 || pos >= entrycount ) {
                    // pos = getInsertionPoint(entryoids,entryoid);
                    // pos = getInsertionPoint(entryoids,entrycount,entryoid);
                    v = new Vector<SnmpVarBind>();
//                  entryoids.add(pos,entryoid);
//                  entrylists.add(pos,v);
//                  isentrynew.add(pos,new Boolean(isnew));
                    add(pos,entryoid,v,isnew,rs);
                }
//              } else v = (Vector) entrylists.get(pos);
                    // } else v = entrylists[pos];
                if (statusvb != null) {
                    if ((rs != null) && (rs != statusvb) &&
                        ((type == SnmpDefinitions.pduWalkRequest) ||
                         (type == SnmpDefinitions.pduSetRequestPdu))) {
                        throw new SnmpStatusException(
                              SnmpStatusException.snmpRspInconsistentValue);
                    }
                    rowstatus[pos] = statusvb;
                }
            }

            // We do not include the status variable in the varbind,
            // because we're going to set it separately...
            //
            if (statusvb != varbind)
                v.addElement(varbind);
        }

        public int getSubReqCount() {
            int count = 0;
            if (sublist != null) count++;
//          if (entryoids != null) count += entryoids.size();
            if (entryoids != null) count += entrycount;
            return count;
        }

        public Vector<SnmpVarBind> getSubList() {
            return sublist;
        }

        public int getEntryPos(SnmpOid entryoid) {
            // return findOid(entryoids,entryoid);
            return findOid(entryoids,entrycount,entryoid);
        }

        public SnmpOid getEntryOid(int pos) {
            if (entryoids == null) return null;
            // if (pos == -1 || pos >= entryoids.size() ) return null;
            if (pos == -1 || pos >= entrycount ) return null;
            // return (SnmpOid) entryoids.get(pos);
            return entryoids[pos];
        }

        public boolean isNewEntry(int pos) {
            if (entryoids == null) return false;
            // if (pos == -1 || pos >= entryoids.size() ) return false;
            if (pos == -1 || pos >= entrycount ) return false;
            // return ((Boolean)isentrynew.get(pos)).booleanValue();
            return isentrynew[pos];
        }

        public SnmpVarBind getRowStatusVarBind(int pos) {
            if (entryoids == null) return null;
            // if (pos == -1 || pos >= entryoids.size() ) return false;
            if (pos == -1 || pos >= entrycount ) return null;
            // return ((Boolean)isentrynew.get(pos)).booleanValue();
            return rowstatus[pos];
        }

        public Vector<SnmpVarBind> getEntrySubList(int pos) {
            if (entrylists == null) return null;
            // if (pos == -1 || pos >= entrylists.size() ) return null;
            if (pos == -1 || pos >= entrycount ) return null;
            // return (Vector) entrylists.get(pos);
            return entrylists[pos];
        }

        public Iterator<SnmpOid> getEntryOids() {
            if (entryoids == null) return null;
            // return entryoids.iterator();
            return Arrays.asList(entryoids).iterator();
        }

        public int getEntryCount() {
            if (entryoids == null) return 0;
            // return entryoids.size();
            return entrycount;
        }

    }


    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    // Public interface
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------

    //-------------------------------------------------------------------
    // Returns the contextual object containing user-data allocated
    // through the SnmpUserDataFactory for this request.
    //-------------------------------------------------------------------

    public Object getUserData() { return request.getUserData(); }

    //-------------------------------------------------------------------
    // Tells whether creation of new entries is allowed with respect
    // to the operation involved (GET=>false/SET=>true)
    //-------------------------------------------------------------------

    public boolean isCreationAllowed() {
        return creationflag;
    }

    //-------------------------------------------------------------------
    // Tells whether we are currently processing a SET request (check/set)
    //-------------------------------------------------------------------

    public boolean isSetRequest() {
        return setreqflag;
    }

    //-------------------------------------------------------------------
    // Returns the protocol version in which the original request is
    // evaluated.
    //-------------------------------------------------------------------

    public int getVersion() {
        return version;
    }

    //-------------------------------------------------------------------
    // Returns the actual protocol version of the request PDU.
    //-------------------------------------------------------------------

    public int getRequestPduVersion() {
        return request.getRequestPduVersion();
    }

    //-------------------------------------------------------------------
    // Returns the SnmpMibNode associated with the given handler
    //-------------------------------------------------------------------

    public SnmpMibNode getMetaNode(Handler handler) {
        return handler.meta;
    }

    //-------------------------------------------------------------------
    // Indicates the depth of the arc in the OID that identifies the
    // SnmpMibNode associated with the given handler
    //-------------------------------------------------------------------

    public int getOidDepth(Handler handler) {
        return handler.depth;
    }

    //-------------------------------------------------------------------
    // returns an enumeration of the SnmpMibSubRequest's to be invoked on
    // the SnmpMibNode associated with a given Handler node.
    // If this node is a group, there will be a single subrequest.
    // If it is a table, there will be one subrequest per entry involved.
    //-------------------------------------------------------------------

    public Enumeration getSubRequests(Handler handler) {
        return new Enum(this,handler);
    }

    //-------------------------------------------------------------------
    // returns an enumeration of the Handlers stored in the Hashtable.
    //-------------------------------------------------------------------

    public Enumeration getHandlers() {
        return hashtable.elements();
    }

    //-------------------------------------------------------------------
    // adds a varbind to a handler node sublist
    //-------------------------------------------------------------------

    public void add(SnmpMibNode meta, int depth, SnmpVarBind varbind)
        throws SnmpStatusException {
        registerNode(meta,depth,null,varbind,false,null);
    }

    //-------------------------------------------------------------------
    // adds an entry varbind to a handler node sublist
    //-------------------------------------------------------------------

    public void add(SnmpMibNode meta, int depth, SnmpOid entryoid,
                    SnmpVarBind varbind, boolean isnew)
        throws SnmpStatusException {
        registerNode(meta,depth,entryoid,varbind,isnew,null);
    }

    //-------------------------------------------------------------------
    // adds an entry varbind to a handler node sublist - specifying the
    // varbind which holds the row status
    //-------------------------------------------------------------------

    public void add(SnmpMibNode meta, int depth, SnmpOid entryoid,
                    SnmpVarBind varbind, boolean isnew,
                    SnmpVarBind statusvb)
        throws SnmpStatusException {
        registerNode(meta,depth,entryoid,varbind,isnew,statusvb);
    }


    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    // Protected interface
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------

    //-------------------------------------------------------------------
    // Type of the request (see SnmpDefinitions)
    //-------------------------------------------------------------------

    void setPduType(int pduType) {
        type = pduType;
        setreqflag = ((pduType == SnmpDefinitions.pduWalkRequest) ||
            (pduType == SnmpDefinitions.pduSetRequestPdu));
    }

    //-------------------------------------------------------------------
    // We deal with a GET-NEXT request
    //-------------------------------------------------------------------

    void setGetNextFlag() {
        getnextflag = true;
    }

    //-------------------------------------------------------------------
    // Tell whether creation is allowed.
    //-------------------------------------------------------------------
    void switchCreationFlag(boolean flag) {
        creationflag = flag;
    }


    //-------------------------------------------------------------------
    // Returns the subrequest handled by the SnmpMibNode itself
    // (in principle, only for Groups)
    //-------------------------------------------------------------------

    SnmpMibSubRequest getSubRequest(Handler handler) {
        if (handler == null) return null;
        return new SnmpMibSubRequestImpl(request,handler.getSubList(),
                                      null,false,getnextflag,null);
    }

    //-------------------------------------------------------------------
    // Returns the subrequest associated with the entry identified by
    // the given entry (only for tables)
    //-------------------------------------------------------------------

    SnmpMibSubRequest getSubRequest(Handler handler, SnmpOid oid) {
        if (handler == null) return null;
        final int pos = handler.getEntryPos(oid);
        if (pos == -1) return null;
        return new SnmpMibSubRequestImpl(request,
                                         handler.getEntrySubList(pos),
                                         handler.getEntryOid(pos),
                                         handler.isNewEntry(pos),
                                         getnextflag,
                                         handler.getRowStatusVarBind(pos));
    }

    //-------------------------------------------------------------------
    // Returns the subrequest associated with the entry identified by
    // the given entry (only for tables). The `entry' parameter is an
    // index relative to the position of the entry in the handler sublist.
    //-------------------------------------------------------------------

    SnmpMibSubRequest getSubRequest(Handler handler, int entry) {
        if (handler == null) return null;
        return new
            SnmpMibSubRequestImpl(request,handler.getEntrySubList(entry),
                                  handler.getEntryOid(entry),
                                  handler.isNewEntry(entry),getnextflag,
                                  handler.getRowStatusVarBind(entry));
    }

    //-------------------------------------------------------------------
    //-------------------------------------------------------------------
    // Private section
    //-------------------------------------------------------------------
    //-------------------------------------------------------------------


    //-------------------------------------------------------------------
    // stores a handler node in the Hashtable
    //-------------------------------------------------------------------

    private void put(Object key, Handler handler) {
        if (handler == null) return;
        if (key == null) return;
        if (hashtable == null) hashtable = new Hashtable<Object, Handler>();
        hashtable.put(key,handler);
    }

    //-------------------------------------------------------------------
    // finds a handler node in the Hashtable
    //-------------------------------------------------------------------

    private Handler get(Object key) {
        if (key == null) return null;
        if (hashtable == null) return null;
        return hashtable.get(key);
    }

    //-------------------------------------------------------------------
    // Search for the given oid in `oids'. If none is found, returns -1
    // otherwise, returns the index at which the oid is located.
    //-------------------------------------------------------------------

    private static int findOid(SnmpOid[] oids, int count, SnmpOid oid) {
        final int size = count;
        int low= 0;
        int max= size - 1;
        int curr= low + (max-low)/2;
        //System.out.println("Try to retrieve: " + oid.toString());
        while (low <= max) {

            final SnmpOid pos = oids[curr];

            //System.out.println("Compare with" + pos.toString());
            // never know ...we might find something ...
            //
            final int comp = oid.compareTo(pos);
            if (comp == 0)
                return curr;

            if (oid.equals(pos)) {
                return curr;
            }
            if (comp > 0) {
                low = curr + 1;
            } else {
                max = curr - 1;
            }
            curr = low + (max-low)/2;
        }
        return -1;
    }

    //-------------------------------------------------------------------
    // Return the index at which the given oid should be inserted in the
    // `oids' array.
    //-------------------------------------------------------------------

    private static int getInsertionPoint(SnmpOid[] oids, int count,
                                         SnmpOid oid) {
        final SnmpOid[] localoids = oids;
        final int size = count;
        int low= 0;
        int max= size - 1;
        int curr= low + (max-low)/2;


        while (low <= max) {

            final SnmpOid pos = localoids[curr];

            // never know ...we might find something ...
            //
            final int comp= oid.compareTo(pos);

            // In the calling method we will have to check for this case...
            //    if (comp == 0)
            //       return -1;
            // Returning curr instead of -1 avoids having to call
            // findOid() first and getInsertionPoint() afterwards.
            // We can simply call getInsertionPoint() and then checks whether
            // there's an OID at the returned position which equals the
            // given OID.
            if (comp == 0)
                return curr;

            if (comp>0) {
                low= curr +1;
            } else {
                max= curr -1;
            }
            curr= low + (max-low)/2;
        }
        return curr;
    }

    //-------------------------------------------------------------------
    // adds a varbind in a handler node sublist
    //-------------------------------------------------------------------

    private void registerNode(SnmpMibNode meta, int depth, SnmpOid entryoid,
                              SnmpVarBind varbind, boolean isnew,
                              SnmpVarBind statusvb)
        throws SnmpStatusException {
        if (meta == null) {
            SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
                    SnmpRequestTree.class.getName(),
                    "registerNode", "meta-node is null!");
            return;
        }
        if (varbind == null) {
            SNMP_ADAPTOR_LOGGER.logp(Level.FINEST,
                    SnmpRequestTree.class.getName(),
                    "registerNode", "varbind is null!");
            return ;
        }

        final Object key = meta;

        // retrieve the handler node associated with the given meta,
        // if any
        Handler handler = get(key);

        // If no handler node was found for that meta, create one.
        if (handler == null) {
            // if (isDebugOn())
            //    debug("registerNode", "adding node for " +
            //          varbind.oid.toString());
            handler = new Handler(type);
            handler.meta  = meta;
            handler.depth = depth;
            put(key,handler);
        }
        // else {
        //   if (isDebugOn())
        //      debug("registerNode","found node for " +
        //            varbind.oid.toString());
        // }

        // Adds the varbind in the handler node's sublist.
        if (entryoid == null)
            handler.addVarbind(varbind);
        else
            handler.addVarbind(varbind,entryoid,isnew,statusvb);
        return ;
    }


    //-------------------------------------------------------------------
    // private variables
    //-------------------------------------------------------------------

    private Hashtable<Object, Handler> hashtable = null;
                                             // Hashtable of Handler objects
    private SnmpMibRequest request = null;   // The original list of varbinds
    private int       version      = 0;      // The protocol version
    private boolean   creationflag = false;  // Does the operation allow
                                             // creation of entries
    private boolean   getnextflag  = false;  // Does the operation allow
                                             // creation of entries
    private int       type         = 0;      // Request PDU type as defined
                                             // in SnmpDefinitions
    private boolean   setreqflag   = false;  // True if we're processing a
                                             // SET request (check/set).
}
