package org.snmp4j.agent.mo;

import java.io.IOException;
import java.util.Iterator;
import java.util.Vector;
import org.snmp4j.agent.DefaultMOScope;
import org.snmp4j.agent.MOAccess;
import org.snmp4j.agent.MOScope;
import org.snmp4j.agent.ManagedObject;
import org.snmp4j.agent.ManagedObjectValueAccess;
import org.snmp4j.agent.SerializableManagedObject;
import org.snmp4j.agent.io.MOInput;
import org.snmp4j.agent.io.MOOutput;
import org.snmp4j.agent.request.RequestStatus;
import org.snmp4j.agent.request.SubRequest;
import org.snmp4j.log.LogAdapter;
import org.snmp4j.log.LogFactory;
import org.snmp4j.smi.Null;
import org.snmp4j.smi.OID;
import org.snmp4j.smi.Variable;
import org.snmp4j.smi.VariableBinding;

/* JADX INFO: loaded from: classes.dex */
public class MOScalar<V extends Variable> implements ManagedObject, MOScope, SerializableManagedObject, ManagedObjectValueAccess {
    private static LogAdapter logger = LogFactory.getLogger(MOScalar.class);
    protected MOAccess access;
    private boolean isVolatile;
    private volatile OID lowerBound;
    private transient Vector<MOChangeListener> moChangeListeners;
    private transient Vector<MOValueValidationListener> moValueValidationListeners;
    protected OID oid;
    private volatile OID upperBound;
    private V value;

    protected MOScalar() {
    }

    private static boolean isVolatileByDefault(Variable variable) {
        int syntax;
        return variable == null || (syntax = variable.getSyntax()) == 65 || syntax == 70;
    }

    public synchronized void addMOChangeListener(MOChangeListener mOChangeListener) {
        if (this.moChangeListeners == null) {
            this.moChangeListeners = new Vector<>(2);
        }
        this.moChangeListeners.add(mOChangeListener);
    }

    public synchronized void addMOValueValidationListener(MOValueValidationListener mOValueValidationListener) {
        if (this.moValueValidationListeners == null) {
            this.moValueValidationListeners = new Vector<>(2);
        }
        this.moValueValidationListeners.add(mOValueValidationListener);
    }

    protected int changeValue(V v) {
        return setValue(v);
    }

    protected boolean checkRequestScope(SubRequest subRequest) {
        if (subRequest.getVariableBinding().getOid().equals(this.oid)) {
            return true;
        }
        VariableBinding variableBinding = subRequest.getVariableBinding();
        variableBinding.setOid(getOid());
        variableBinding.setVariable(Null.noSuchInstance);
        subRequest.completed();
        return false;
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void cleanup(SubRequest subRequest) {
        subRequest.setUndoValue(null);
        subRequest.getStatus().setPhaseComplete(true);
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void commit(SubRequest subRequest) {
        RequestStatus status = subRequest.getStatus();
        VariableBinding variableBinding = subRequest.getVariableBinding();
        if (this.moChangeListeners != null) {
            fireBeforeMOChange(new MOChangeEvent(this, this, variableBinding.getOid(), getValue(), variableBinding.getVariable(), false));
        }
        subRequest.setUndoValue(getValue());
        changeValue(variableBinding.getVariable());
        status.setPhaseComplete(true);
        if (this.moChangeListeners != null) {
            fireAfterMOChange(new MOChangeEvent(this, this, subRequest.getVariableBinding().getOid(), (Variable) subRequest.getUndoValue(), variableBinding.getVariable(), false));
        }
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean covers(OID oid) {
        return oid.startsWith(this.oid);
    }

    @Override // org.snmp4j.agent.ManagedObject
    public OID find(MOScope mOScope) {
        if (this.access.isAccessibleForRead() && mOScope.isCovered(getSingleInstanceScope())) {
            if (logger.isDebugEnabled()) {
                logger.debug("MOScalar '" + this.oid + "' is in scope '" + mOScope + "'");
            }
            return this.oid;
        }
        if (!logger.isDebugEnabled()) {
            return null;
        }
        logger.debug("MOScalar '" + this.oid + "' is not in scope '" + mOScope + "'");
        return null;
    }

    protected void fireAfterMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            Iterator<MOChangeListener> it = vector.iterator();
            while (it.hasNext()) {
                it.next().afterMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireAfterPrepareMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            Iterator<MOChangeListener> it = vector.iterator();
            while (it.hasNext()) {
                it.next().afterPrepareMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireBeforeMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            Iterator<MOChangeListener> it = vector.iterator();
            while (it.hasNext()) {
                it.next().beforeMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireBeforePrepareMOChange(MOChangeEvent mOChangeEvent) {
        Vector<MOChangeListener> vector = this.moChangeListeners;
        if (vector != null) {
            Iterator<MOChangeListener> it = vector.iterator();
            while (it.hasNext()) {
                it.next().beforePrepareMOChange(mOChangeEvent);
            }
        }
    }

    protected void fireValidate(MOValueValidationEvent mOValueValidationEvent) {
        Vector<MOValueValidationListener> vector = this.moValueValidationListeners;
        if (vector != null) {
            int size = vector.size();
            for (int i2 = 0; i2 < size; i2++) {
                vector.elementAt(i2).validate(mOValueValidationEvent);
            }
        }
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void get(SubRequest subRequest) {
        RequestStatus status = subRequest.getStatus();
        if (checkRequestScope(subRequest)) {
            if (!this.access.isAccessibleForRead()) {
                status.setErrorStatus(6);
                return;
            }
            VariableBinding variableBinding = subRequest.getVariableBinding();
            variableBinding.setOid(getOid());
            Variable value = getValue();
            if (value == null) {
                variableBinding.setVariable(Null.noSuchObject);
            } else {
                variableBinding.setVariable((Variable) value.clone());
            }
            subRequest.completed();
        }
    }

    public MOAccess getAccess() {
        return this.access;
    }

    @Override // org.snmp4j.agent.RegisteredManagedObject
    public OID getID() {
        return getOid();
    }

    @Override // org.snmp4j.agent.MOScope
    public OID getLowerBound() {
        if (this.lowerBound == null) {
            this.lowerBound = new OID(this.oid.getValue(), 0, this.oid.size() - 1);
        }
        return this.lowerBound;
    }

    public OID getOid() {
        return this.oid;
    }

    @Override // org.snmp4j.agent.ManagedObject
    public MOScope getScope() {
        return this;
    }

    public MOScope getSingleInstanceScope() {
        OID oid = this.oid;
        return new DefaultMOScope(oid, true, oid, true);
    }

    @Override // org.snmp4j.agent.MOScope
    public OID getUpperBound() {
        if (this.upperBound == null) {
            this.upperBound = new OID(getLowerBound().nextPeer());
        }
        return this.upperBound;
    }

    public V getValue() {
        return this.value;
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isCovered(MOScope mOScope) {
        return mOScope.getLowerBound().startsWith(this.oid) && (mOScope.getLowerBound().size() > this.oid.size() || mOScope.isLowerIncluded()) && mOScope.getUpperBound().startsWith(this.oid) && (mOScope.getUpperBound().size() > this.oid.size() || mOScope.isUpperIncluded());
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isLowerIncluded() {
        return true;
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isOverlapping(MOScope mOScope) {
        return DefaultMOScope.overlaps(this, mOScope);
    }

    @Override // org.snmp4j.agent.MOScope
    public boolean isUpperIncluded() {
        return false;
    }

    public int isValueOK(SubRequest subRequest) {
        if (this.moValueValidationListeners == null) {
            return 0;
        }
        MOValueValidationEvent mOValueValidationEvent = new MOValueValidationEvent(this, this.value, subRequest.getVariableBinding().getVariable());
        fireValidate(mOValueValidationEvent);
        return mOValueValidationEvent.getValidationStatus();
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public boolean isVolatile() {
        return this.isVolatile;
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public synchronized void load(MOInput mOInput) throws IOException {
        setValue(mOInput.readVariable());
    }

    @Override // org.snmp4j.agent.ManagedObject
    public boolean next(SubRequest subRequest) {
        if (!this.access.isAccessibleForRead() || !subRequest.getScope().isCovered(getSingleInstanceScope())) {
            if (logger.isDebugEnabled()) {
                logger.debug("Skipped '" + getOid() + "' for GETNEXT/BULK request '" + subRequest + "'");
            }
            return false;
        }
        VariableBinding variableBinding = subRequest.getVariableBinding();
        variableBinding.setOid(getOid());
        Variable value = getValue();
        if (value == null) {
            if (logger.isDebugEnabled()) {
                logger.debug("Skipped '" + getOid() + "' for GETNEXT/BULK request '" + subRequest + "' because variable is NULL");
            }
            return false;
        }
        variableBinding.setVariable((Variable) value.clone());
        subRequest.completed();
        if (!logger.isDebugEnabled()) {
            return true;
        }
        logger.debug("Processed GETNEXT/BULK request '" + subRequest + "' by '" + getOid());
        return true;
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void prepare(SubRequest subRequest) {
        RequestStatus status = subRequest.getStatus();
        if (!this.oid.equals(subRequest.getVariableBinding().getOid())) {
            status.setErrorStatus(11);
            return;
        }
        if (!this.access.isAccessibleForWrite()) {
            status.setErrorStatus(17);
            return;
        }
        if (subRequest.getVariableBinding().getVariable().getSyntax() != getValue().getSyntax()) {
            status.setErrorStatus(7);
            return;
        }
        if (this.moChangeListeners != null) {
            MOChangeEvent mOChangeEvent = new MOChangeEvent(this, this, subRequest.getVariableBinding().getOid(), getValue(), subRequest.getVariableBinding().getVariable(), true);
            fireBeforePrepareMOChange(mOChangeEvent);
            if (mOChangeEvent.getDenyReason() != 0) {
                status.setErrorStatus(mOChangeEvent.getDenyReason());
                status.setPhaseComplete(true);
                return;
            }
        }
        int iIsValueOK = isValueOK(subRequest);
        if (this.moChangeListeners != null && iIsValueOK == 0) {
            MOChangeEvent mOChangeEvent2 = new MOChangeEvent(this, this, subRequest.getVariableBinding().getOid(), getValue(), subRequest.getVariableBinding().getVariable(), true);
            fireAfterPrepareMOChange(mOChangeEvent2);
            iIsValueOK = mOChangeEvent2.getDenyReason();
        }
        status.setErrorStatus(iIsValueOK);
        status.setPhaseComplete(true);
    }

    public synchronized void removeMOChangeListener(MOChangeListener mOChangeListener) {
        if (this.moChangeListeners != null) {
            this.moChangeListeners.remove(mOChangeListener);
        }
    }

    public synchronized void removeMOValueValidationListener(MOValueValidationListener mOValueValidationListener) {
        if (this.moValueValidationListeners != null) {
            this.moValueValidationListeners.remove(mOValueValidationListener);
        }
    }

    @Override // org.snmp4j.agent.SerializableManagedObject
    public synchronized void save(MOOutput mOOutput) throws IOException {
        mOOutput.writeVariable(this.value);
    }

    public int setValue(V v) {
        this.value = v;
        return 0;
    }

    public void setVolatile(boolean z) {
        this.isVolatile = z;
    }

    public String toString() {
        return getClass().getName() + "[oid=" + getOid() + ",access=" + this.access + ",value=" + getValue() + ",volatile=" + isVolatile() + toStringDetails() + "]";
    }

    protected String toStringDetails() {
        return "";
    }

    @Override // org.snmp4j.agent.ManagedObject
    public void undo(SubRequest subRequest) {
        RequestStatus status = subRequest.getStatus();
        if (subRequest.getUndoValue() == null || !(subRequest.getUndoValue() instanceof Variable)) {
            status.setErrorStatus(15);
        } else {
            status.setErrorStatus(changeValue((Variable) subRequest.getUndoValue()));
            status.setPhaseComplete(true);
        }
    }

    public MOScalar(OID oid, MOAccess mOAccess, V v) {
        this.oid = oid;
        this.access = mOAccess;
        this.value = v;
        this.isVolatile = isVolatileByDefault(v);
    }

    @Override // org.snmp4j.agent.ManagedObjectValueAccess
    public Variable getValue(OID oid) {
        if (getOid().equals(oid)) {
            return getValue();
        }
        return null;
    }

    @Override // org.snmp4j.agent.ManagedObjectValueAccess
    public boolean setValue(VariableBinding variableBinding) {
        return getOid().equals(variableBinding.getOid()) && setValue(variableBinding.getVariable()) == 0;
    }
}