/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Constructs the Java Dynamic Management(TM) Access Control List
 * based on IP addresses. The ACL will take the given owner name.
 * The current IP address will be the owner of the ACL.
 *
 * @param Owner The name of the ACL Owner.
 * @param aclFileName The name of the ACL File.
 *
 * @exception UnknownHostException If the local host is unknown.
 * @exception IllegalArgumentException If the ACL file doesn't exist.
 */
public SnmpAcl(String Owner, String aclFileName)
    throws UnknownHostException, IllegalArgumentException {
    trapDestList= new Hashtable<InetAddress, Vector<String>>();
    informDestList= new Hashtable<InetAddress, Vector<String>>();

    // PrincipalImpl() take the current host as entry
    owner = new PrincipalImpl();
    try {
        acl = new AclImpl(owner,Owner);
        AclEntry ownEntry = new AclEntryImpl(owner);
        ownEntry.addPermission(READ);
        ownEntry.addPermission(WRITE);
        acl.addEntry(owner,ownEntry);
    } catch (NotOwnerException ex) {
        if (SNMP_LOGGER.isLoggable(Level.FINEST)) {
            SNMP_LOGGER.logp(Level.FINEST, SnmpAcl.class.getName(),
                "SnmpAcl(String,String)",
                "Should never get NotOwnerException as the owner " +
                "is built in this constructor");
        }
    }
    if (aclFileName == null) setDefaultFileName();
    else setAuthorizedListFile(aclFileName);
    readAuthorizedListFile();
}
 

/**
 * Deletes an owner. If this is the last owner in the ACL, an exception is raised.
 *<P>
 * The caller principal must be an owner of the ACL in order to invoke this method.
 *
 * @param caller the principal invoking this method. It must be an owner
 *   of the ACL.
 * @param owner the owner to be removed from the list of owners.
 * @return true if successful, false if owner is already an owner.
 * @exception NotOwnerException if the caller principal is not an owner
 *   of the ACL.
 * @exception LastOwnerException if there is only one owner left, so that
 *   deleteOwner would leave the ACL owner-less.
 */
public boolean deleteOwner(Principal caller, Principal owner)
              throws NotOwnerException,LastOwnerException {

      if (!ownerList.contains(caller))
        throw new NotOwnerException();

      if (!ownerList.contains(owner)){
        return false;
      } else {
        if (ownerList.size() == 1)
              throw new LastOwnerException();

        ownerList.removeElement(owner);
        return true;
      }
}
 

/**
 * Adds an ACL entry to this ACL. An entry associates a principal (e.g., an individual or a group)
 * with a set of permissions. Each principal can have at most one positive ACL entry
 * (specifying permissions to be granted to the principal) and one negative ACL entry
 * (specifying permissions to be denied). If there is already an ACL entry
 * of the same type (negative or positive) already in the ACL, false is returned.
 *
 * @param caller the principal invoking this method. It must be an owner
 *        of this ACL.
 * @param entry the ACL entry to be added to this ACL.
 * @return true on success, false if an entry of the same type (positive
 *       or negative) for the same principal is already present in this ACL.
 * @exception NotOwnerException if the caller principal is not an owner of
 *       this ACL.
 * @see java.security.Principal
 */
@Override
public boolean addEntry(Principal caller, AclEntry entry)
      throws NotOwnerException {
        if (!isOwner(caller))
              throw new NotOwnerException();

        if (entryList.contains(entry))
              return false;
        /*
               for (Enumeration e = entryList.elements();e.hasMoreElements();){
               AclEntry ent = (AclEntry) e.nextElement();
               if (ent.getPrincipal().equals(entry.getPrincipal()))
               return false;
               }
               */

        entryList.addElement(entry);
        return true;
}
 

/**
 * Resets this ACL to the values contained in the configuration file.
 *
 * @exception NotOwnerException If the principal attempting the reset is not an owner of this ACL.
 * @exception UnknownHostException If IP addresses for hosts contained in the ACL file couldn't be found.
 */
public void rereadTheFile() throws NotOwnerException, UnknownHostException {
    alwaysAuthorized = false;
    acl.removeAll(owner);
    trapDestList.clear();
    informDestList.clear();
    AclEntry ownEntry = new AclEntryImpl(owner);
    ownEntry.addPermission(READ);
    ownEntry.addPermission(WRITE);
    acl.addEntry(owner,ownEntry);
    readAuthorizedListFile();
}