001: /*_############################################################################
002: _##
003: _## SNMP4J-Agent - SnmpTargetMIB.java
004: _##
005: _## Copyright (C) 2005-2007 Frank Fock (SNMP4J.org)
006: _##
007: _## Licensed under the Apache License, Version 2.0 (the "License");
008: _## you may not use this file except in compliance with the License.
009: _## You may obtain a copy of the License at
010: _##
011: _## http://www.apache.org/licenses/LICENSE-2.0
012: _##
013: _## Unless required by applicable law or agreed to in writing, software
014: _## distributed under the License is distributed on an "AS IS" BASIS,
015: _## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
016: _## See the License for the specific language governing permissions and
017: _## limitations under the License.
018: _##
019: _##########################################################################*/
020:
021: package org.snmp4j.agent.mo.snmp;
022:
023: //--AgentGen BEGIN=_BEGIN
024: //--AgentGen END
025:
026: import java.util.*;
027:
028: import org.snmp4j.*;
029: import org.snmp4j.agent.*;
030: import org.snmp4j.agent.mo.*;
031: import org.snmp4j.agent.request.*;
032: import org.snmp4j.event.*;
033: import org.snmp4j.log.*;
034: import org.snmp4j.mp.*;
035: import org.snmp4j.security.*;
036: import org.snmp4j.smi.*;
037:
038: //--AgentGen BEGIN=_IMPORT
039: //--AgentGen END
040:
041: public class SnmpTargetMIB implements MOGroup, CounterListener,
042: MOTableRowListener {
043:
044: private static final LogAdapter logger = LogFactory
045: .getLogger(SnmpTargetMIB.class);
046:
047: // Constants
048: private static final OID oidSnmpTargetSpinLock = new OID(new int[] {
049: 1, 3, 6, 1, 6, 3, 12, 1, 1, 0 });
050:
051: private MOScalar snmpTargetSpinLock;
052:
053: private static final OID oidSnmpUnknownContexts = new OID(
054: new int[] { 1, 3, 6, 1, 6, 3, 12, 1, 5, 0 });
055:
056: private MOScalar snmpUnknownContexts;
057:
058: private static final OID oidSnmpUnavailableContexts = new OID(
059: new int[] { 1, 3, 6, 1, 6, 3, 12, 1, 4, 0 });
060:
061: private MOScalar snmpUnavailableContexts;
062:
063: private static final OID oidSnmpTargetParamsEntry = new OID(
064: new int[] { 1, 3, 6, 1, 6, 3, 12, 1, 3, 1 });
065:
066: // Column sub-identifer defintions for snmpTargetParamsEntry:
067: private static final int colSnmpTargetParamsMPModel = 2;
068: private static final int colSnmpTargetParamsSecurityModel = 3;
069: private static final int colSnmpTargetParamsSecurityName = 4;
070: private static final int colSnmpTargetParamsSecurityLevel = 5;
071: private static final int colSnmpTargetParamsStorageType = 6;
072: private static final int colSnmpTargetParamsRowStatus = 7;
073:
074: // Column index defintions for snmpTargetParamsEntry:
075: static final int idxSnmpTargetParamsMPModel = 0;
076: static final int idxSnmpTargetParamsSecurityModel = 1;
077: static final int idxSnmpTargetParamsSecurityName = 2;
078: static final int idxSnmpTargetParamsSecurityLevel = 3;
079: static final int idxSnmpTargetParamsStorageType = 4;
080: static final int idxSnmpTargetParamsRowStatus = 5;
081: private static MOTableSubIndex[] snmpTargetParamsEntryIndexes = new MOTableSubIndex[] { new MOTableSubIndex(
082: SMIConstants.SYNTAX_OCTET_STRING, 1, 32) };
083:
084: private static MOTableIndex snmpTargetParamsEntryIndex = new MOTableIndex(
085: snmpTargetParamsEntryIndexes, true) {
086: public boolean isValidIndex(OID index) {
087: boolean isValidIndex = super .isValidIndex(index);
088: if (isValidIndex) {
089: //--AgentGen BEGIN=snmpTargetParamsEntry::isValidIndex
090: //--AgentGen END
091: }
092: return isValidIndex;
093: }
094: };
095:
096: private DefaultMOTable snmpTargetParamsEntry;
097: private DefaultMOMutableTableModel snmpTargetParamsEntryModel;
098: private static final OID oidSnmpTargetAddrEntry = new OID(
099: new int[] { 1, 3, 6, 1, 6, 3, 12, 1, 2, 1 });
100:
101: // Column sub-identifer defintions for snmpTargetAddrEntry:
102: private static final int colSnmpTargetAddrTDomain = 2;
103: private static final int colSnmpTargetAddrTAddress = 3;
104: private static final int colSnmpTargetAddrTimeout = 4;
105: private static final int colSnmpTargetAddrRetryCount = 5;
106: private static final int colSnmpTargetAddrTagList = 6;
107: private static final int colSnmpTargetAddrParams = 7;
108: private static final int colSnmpTargetAddrStorageType = 8;
109: private static final int colSnmpTargetAddrRowStatus = 9;
110:
111: // Column index defintions for snmpTargetAddrEntry:
112: static final int idxSnmpTargetAddrTDomain = 0;
113: static final int idxSnmpTargetAddrTAddress = 1;
114: static final int idxSnmpTargetAddrTimeout = 2;
115: static final int idxSnmpTargetAddrRetryCount = 3;
116: static final int idxSnmpTargetAddrTagList = 4;
117: static final int idxSnmpTargetAddrParams = 5;
118: static final int idxSnmpTargetAddrStorageType = 6;
119: static final int idxSnmpTargetAddrRowStatus = 7;
120: private static MOTableSubIndex[] snmpTargetAddrEntryIndexes = new MOTableSubIndex[] { new MOTableSubIndex(
121: SMIConstants.SYNTAX_OCTET_STRING, 1, 32) };
122:
123: private static MOTableIndex snmpTargetAddrEntryIndex = new MOTableIndex(
124: snmpTargetAddrEntryIndexes, true) {
125: public boolean isValidIndex(OID index) {
126: boolean isValidIndex = super .isValidIndex(index);
127: if (isValidIndex) {
128: //--AgentGen BEGIN=snmpTargetAddrEntry::isValidIndex
129: //--AgentGen END
130: }
131: return isValidIndex;
132: }
133: };
134:
135: private static final OID[] DEFAULT_TDOMAINS = {
136: TransportDomains.snmpUDPDomain,
137: TransportDomains.transportDomainTcpIpv4,
138: TransportDomains.transportDomainTcpIpv6,
139: TransportDomains.transportDomainUdpIpv4,
140: TransportDomains.transportDomainUdpIpv6 };
141:
142: private DefaultMOTable snmpTargetAddrEntry;
143: private DefaultMOMutableTableModel snmpTargetAddrEntryModel;
144:
145: private Hashtable snmpTargetAddrTagIndex = new Hashtable();
146:
147: // maps TDomain OIDs to TDomainAddressFactory instances
148: private Hashtable supportedAddressClasses = new Hashtable();
149: private Snmp session;
150: private CoexistenceInfoProvider coexistenceProvider;
151:
152: public SnmpTargetMIB(Snmp session) {
153: this .session = session;
154: snmpTargetSpinLock = new TestAndIncr(oidSnmpTargetSpinLock);
155: snmpUnknownContexts = new MOScalar(oidSnmpUnknownContexts,
156: MOAccessImpl.ACCESS_READ_ONLY, new Counter32());
157: snmpUnavailableContexts = new MOScalar(
158: oidSnmpUnavailableContexts,
159: MOAccessImpl.ACCESS_READ_ONLY, new Counter32());
160: createSnmpTargetParamsEntry();
161: createSnmpTargetAddrEntry();
162: }
163:
164: public Collection getTargetAddrRowsForTag(OctetString tag) {
165: Collection l = (Collection) snmpTargetAddrTagIndex.get(tag);
166: if (l == null) {
167: return Collections.EMPTY_SET;
168: } else {
169: synchronized (l) {
170: l = new ArrayList(l);
171: }
172: }
173: return l;
174: }
175:
176: public Address getTargetAddress(OctetString name) {
177: OID index = name.toSubIndex(true);
178: SnmpTargetAddrEntryRow trow = (SnmpTargetAddrEntryRow) this .snmpTargetAddrEntryModel
179: .getRow(index);
180: if (trow != null) {
181: return trow.getAddress();
182: }
183: return null;
184: }
185:
186: public Target getTarget(OctetString name,
187: OctetString contextEngineID, OctetString contextName) {
188: OID index = name.toSubIndex(true);
189: SnmpTargetAddrEntryRow trow = (SnmpTargetAddrEntryRow) this .snmpTargetAddrEntryModel
190: .getRow(index);
191: if (trow != null) {
192: return trow.getTarget(contextEngineID, contextName);
193: }
194: return null;
195: }
196:
197: public void addDefaultTDomains() {
198: TDomainAddressFactoryImpl factory = new TDomainAddressFactoryImpl();
199: for (int i = 0; i < DEFAULT_TDOMAINS.length; i++) {
200: supportedAddressClasses.put(DEFAULT_TDOMAINS[i], factory);
201: }
202: }
203:
204: public void addSupportedTDomain(OID transportDomain,
205: TDomainAddressFactory factory) {
206: supportedAddressClasses.put(transportDomain, factory);
207: }
208:
209: public boolean addTargetAddress(OctetString name,
210: OID transportDomain, OctetString address, int timeout,
211: int retries, OctetString tagList, OctetString params,
212: int storageType) {
213: Variable[] vbs = new Variable[snmpTargetAddrEntry
214: .getColumnCount()];
215: int n = 0;
216: vbs[n++] = transportDomain;
217: vbs[n++] = address;
218: vbs[n++] = new Integer32(timeout);
219: vbs[n++] = new Integer32(retries);
220: vbs[n++] = tagList;
221: vbs[n++] = params;
222: vbs[n++] = new Integer32(storageType);
223: vbs[n++] = new Integer32(RowStatus.active);
224: OID index = name.toSubIndex(true);
225: MOTableRow row = snmpTargetAddrEntry.createRow(index, vbs);
226: snmpTargetAddrEntry.addRow(row);
227: return true;
228: }
229:
230: public MOTableRow removeTargetAddress(OctetString name) {
231: OID index = name.toSubIndex(true);
232: MOTableRow removedRow = snmpTargetAddrEntryModel
233: .removeRow(index);
234: if (removedRow != null) {
235: removeRowFromTargetAddrTagIndex(removedRow);
236: }
237: return removedRow;
238: }
239:
240: protected void removeRowFromTargetAddrTagIndex(MOTableRow removedRow) {
241: OctetString tagList = (OctetString) removedRow
242: .getValue(idxSnmpTargetAddrTagList);
243: Set tags = SnmpTagList.getTags(tagList);
244: if ((tags != null) && (this .snmpTargetAddrTagIndex != null)) {
245: for (Iterator it = tags.iterator(); it.hasNext();) {
246: Object item = it.next();
247: Collection indexRows = (Collection) this .snmpTargetAddrTagIndex
248: .get(item);
249: if (indexRows != null) {
250: synchronized (indexRows) {
251: indexRows.remove(removedRow);
252: if (indexRows.isEmpty()) {
253: this .snmpTargetAddrTagIndex.remove(item);
254: }
255: }
256: }
257: }
258: }
259: }
260:
261: public boolean addTargetParams(OctetString name, int mpModel,
262: int secModel, OctetString secName, int secLevel,
263: int storageType) {
264: Variable[] vbs = new Variable[snmpTargetParamsEntry
265: .getColumnCount()];
266: int n = 0;
267: vbs[n++] = new Integer32(mpModel);
268: vbs[n++] = new Integer32(secModel);
269: vbs[n++] = secName;
270: vbs[n++] = new Integer32(secLevel);
271: vbs[n++] = new Integer32(storageType);
272: vbs[n++] = new Integer32(RowStatus.active);
273: OID index = name.toSubIndex(true);
274: MOTableRow row = snmpTargetParamsEntry.createRow(index, vbs);
275: snmpTargetParamsEntry.addRow(row);
276: return true;
277: }
278:
279: public MOTableRow removeTargetParams(OctetString name) {
280: OID index = name.toSubIndex(true);
281: return snmpTargetParamsEntry.removeRow(index);
282: }
283:
284: private void createSnmpTargetParamsEntry() {
285: MOColumn[] snmpTargetParamsEntryColumns = new MOColumn[6];
286: snmpTargetParamsEntryColumns[idxSnmpTargetParamsMPModel] = new MOMutableColumn(
287: colSnmpTargetParamsMPModel,
288: SMIConstants.SYNTAX_INTEGER,
289: MOAccessImpl.ACCESS_READ_CREATE, null, false);
290: ((MOMutableColumn) snmpTargetParamsEntryColumns[idxSnmpTargetParamsMPModel])
291: .addMOValueValidationListener(new SnmpTargetParamsMPModelValidator());
292: snmpTargetParamsEntryColumns[idxSnmpTargetParamsSecurityModel] = new MOMutableColumn(
293: colSnmpTargetParamsSecurityModel,
294: SMIConstants.SYNTAX_INTEGER,
295: MOAccessImpl.ACCESS_READ_CREATE, null, false);
296: ((MOMutableColumn) snmpTargetParamsEntryColumns[idxSnmpTargetParamsSecurityModel])
297: .addMOValueValidationListener(new SnmpTargetParamsSecurityModelValidator());
298: snmpTargetParamsEntryColumns[idxSnmpTargetParamsSecurityName] = new SnmpAdminString(
299: colSnmpTargetParamsSecurityName,
300: MOAccessImpl.ACCESS_READ_CREATE, null, false);
301: snmpTargetParamsEntryColumns[idxSnmpTargetParamsSecurityLevel] = new Enumerated(
302: colSnmpTargetParamsSecurityLevel,
303: MOAccessImpl.ACCESS_READ_CREATE, null, false,
304: new int[] {
305: SnmpTargetParamsSecurityLevelEnum.noAuthNoPriv,
306: SnmpTargetParamsSecurityLevelEnum.authPriv,
307: SnmpTargetParamsSecurityLevelEnum.authNoPriv });
308: snmpTargetParamsEntryColumns[idxSnmpTargetParamsStorageType] = new StorageType(
309: colSnmpTargetParamsStorageType,
310: MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true);
311: snmpTargetParamsEntryColumns[idxSnmpTargetParamsRowStatus] = new RowStatus(
312: colSnmpTargetParamsRowStatus,
313: MOAccessImpl.ACCESS_READ_CREATE);
314: ((RowStatus) snmpTargetParamsEntryColumns[idxSnmpTargetParamsRowStatus])
315: .addRowStatusListener(new SnmpTargetParamsEntryRowStatusListener());
316:
317: snmpTargetParamsEntry = new DefaultMOTable(
318: oidSnmpTargetParamsEntry, snmpTargetParamsEntryIndex,
319: snmpTargetParamsEntryColumns);
320: snmpTargetParamsEntryModel = new DefaultMOMutableTableModel();
321: snmpTargetParamsEntryModel
322: .setRowFactory(new DefaultMOMutableRow2PCFactory());
323: snmpTargetParamsEntry.setModel(snmpTargetParamsEntryModel);
324: }
325:
326: private void createSnmpTargetAddrEntry() {
327: MOColumn[] snmpTargetAddrEntryColumns = new MOColumn[8];
328: snmpTargetAddrEntryColumns[idxSnmpTargetAddrTDomain] = new MOMutableColumn(
329: colSnmpTargetAddrTDomain,
330: SMIConstants.SYNTAX_OBJECT_IDENTIFIER,
331: MOAccessImpl.ACCESS_READ_CREATE, null, false);
332: ((MOMutableColumn) snmpTargetAddrEntryColumns[idxSnmpTargetAddrTDomain])
333: .addMOValueValidationListener(new SnmpTargetAddrTDomainValidator());
334: snmpTargetAddrEntryColumns[idxSnmpTargetAddrTAddress] = new MOMutableColumn(
335: colSnmpTargetAddrTAddress,
336: SMIConstants.SYNTAX_OCTET_STRING,
337: MOAccessImpl.ACCESS_READ_CREATE, null, false);
338: ((MOMutableColumn) snmpTargetAddrEntryColumns[idxSnmpTargetAddrTAddress])
339: .addMOValueValidationListener(new SnmpTargetAddrTAddressValidator());
340: snmpTargetAddrEntryColumns[idxSnmpTargetAddrTimeout] = new MOMutableColumn(
341: colSnmpTargetAddrTimeout, SMIConstants.SYNTAX_INTEGER,
342: MOAccessImpl.ACCESS_READ_CREATE, new Integer32(1500),
343: true);
344: ((MOMutableColumn) snmpTargetAddrEntryColumns[idxSnmpTargetAddrTimeout])
345: .addMOValueValidationListener(new SnmpTargetAddrTimeoutValidator());
346: snmpTargetAddrEntryColumns[idxSnmpTargetAddrRetryCount] = new MOMutableColumn(
347: colSnmpTargetAddrRetryCount,
348: SMIConstants.SYNTAX_INTEGER32,
349: MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true);
350: ((MOMutableColumn) snmpTargetAddrEntryColumns[idxSnmpTargetAddrRetryCount])
351: .addMOValueValidationListener(new SnmpTargetAddrRetryCountValidator());
352: snmpTargetAddrEntryColumns[idxSnmpTargetAddrTagList] = new SnmpTagList(
353: colSnmpTargetAddrTagList,
354: MOAccessImpl.ACCESS_READ_CREATE, new OctetString(
355: new byte[] {}), true);
356: snmpTargetAddrEntryColumns[idxSnmpTargetAddrParams] = new MOMutableColumn(
357: colSnmpTargetAddrParams,
358: SMIConstants.SYNTAX_OCTET_STRING,
359: MOAccessImpl.ACCESS_READ_CREATE, new OctetString(),
360: true);
361: ((MOMutableColumn) snmpTargetAddrEntryColumns[idxSnmpTargetAddrParams])
362: .addMOValueValidationListener(new SnmpTargetAddrParamsValidator());
363: snmpTargetAddrEntryColumns[idxSnmpTargetAddrStorageType] = new StorageType(
364: colSnmpTargetAddrStorageType,
365: MOAccessImpl.ACCESS_READ_CREATE, new Integer32(3), true);
366: snmpTargetAddrEntryColumns[idxSnmpTargetAddrRowStatus] = new RowStatus(
367: colSnmpTargetAddrRowStatus);
368: snmpTargetAddrEntry = new DefaultMOTable(
369: oidSnmpTargetAddrEntry, snmpTargetAddrEntryIndex,
370: snmpTargetAddrEntryColumns);
371: snmpTargetAddrEntryModel = new DefaultMOMutableTableModel();
372: snmpTargetAddrEntryModel
373: .setRowFactory(new SnmpTargetAddrEntryFactory());
374: snmpTargetAddrEntry.setModel(snmpTargetAddrEntryModel);
375: }
376:
377: public void registerMOs(MOServer server, OctetString context)
378: throws DuplicateRegistrationException {
379: // Scalar Objects
380: server.register(this .snmpTargetSpinLock, context);
381: server.register(this .snmpUnknownContexts, context);
382: server.register(this .snmpUnavailableContexts, context);
383: server.register(this .snmpTargetParamsEntry, context);
384: server.register(this .snmpTargetAddrEntry, context);
385: }
386:
387: public void unregisterMOs(MOServer server, OctetString context) {
388: // Scalar Objects
389: server.unregister(this .snmpTargetSpinLock, context);
390: server.unregister(this .snmpUnknownContexts, context);
391: server.unregister(this .snmpUnavailableContexts, context);
392: server.unregister(this .snmpTargetParamsEntry, context);
393: server.unregister(this .snmpTargetAddrEntry, context);
394: }
395:
396: class SnmpTargetAddrEntryFactory implements MOTableRowFactory {
397:
398: public MOTableRow createRow(OID index, Variable[] values)
399: throws UnsupportedOperationException {
400: SnmpTargetAddrEntryRow row = new SnmpTargetAddrEntryRow(
401: index, values);
402: return row;
403: }
404:
405: public void freeRow(MOTableRow row) {
406: }
407:
408: }
409:
410: class SnmpTargetParamsEntryRowStatusListener implements
411: RowStatusListener {
412:
413: public void rowStatusChanged(RowStatusEvent event) {
414: if (event.getNewStatus() == RowStatus.destroy) {
415: OID index = event.getRow().getIndex();
416: OctetString paramsIndex = (OctetString) snmpTargetParamsEntryIndex
417: .getIndexValues(index)[0];
418: synchronized (snmpTargetAddrEntryModel) {
419: for (Iterator it = snmpTargetAddrEntryModel
420: .iterator(); it.hasNext();) {
421: MOTableRow r = (MOTableRow) it.next();
422: Integer32 rowStatus = (Integer32) r
423: .getValue(idxSnmpTargetAddrRowStatus);
424: if ((rowStatus == null)
425: || (rowStatus.getValue() != RowStatus.active)) {
426: continue;
427: }
428: if (paramsIndex.equals(r
429: .getValue(idxSnmpTargetAddrParams))) {
430: event
431: .setDenyReason(SnmpConstants.SNMP_ERROR_INCONSISTENT_VALUE);
432: return;
433: }
434: }
435: }
436: }
437: }
438:
439: }
440:
441: public class SnmpTargetAddrEntryRow extends DefaultMOMutableRow2PC {
442: public SnmpTargetAddrEntryRow(OID index, Variable[] values) {
443: super (index, values);
444: updateUserObject(this );
445: }
446:
447: private void updateUserObject(MOTableRow changeSet) {
448: Variable tagList = changeSet
449: .getValue(idxSnmpTargetAddrTagList);
450: if (tagList != null) {
451: Set obsolete = (Set) getUserObject();
452: Set tags = SnmpTagList.getTags((OctetString) tagList);
453: if (obsolete != null) {
454: obsolete.removeAll(tags);
455: }
456: setUserObject(tags);
457: updateIndex(obsolete, tags);
458: }
459: }
460:
461: public void commitRow(SubRequest subRequest,
462: MOTableRow changeSet) {
463: super .commitRow(subRequest, changeSet);
464: updateUserObject(changeSet);
465: }
466:
467: private void updateIndex(Set remove, Set tags) {
468: if (remove != null) {
469: for (Iterator it = remove.iterator(); it.hasNext();) {
470: Object next = it.next();
471: Collection list = (Collection) snmpTargetAddrTagIndex
472: .get(next);
473: if (list != null) {
474: synchronized (list) {
475: if (!list.remove(this )) {
476: logger.error("Inconsistent tag value '"
477: + next + "' for rows: " + list);
478: }
479: }
480: } else {
481: logger.error("Tag value '" + next
482: + "' not found in tag index");
483: }
484: }
485: }
486: for (Iterator it = tags.iterator(); it.hasNext();) {
487: Object next = it.next();
488: Set list = (Set) snmpTargetAddrTagIndex.get(next);
489: if (list == null) {
490: list = new HashSet();
491: }
492: synchronized (list) {
493: list.add(this );
494: }
495: snmpTargetAddrTagIndex.put(next, list);
496: }
497: }
498:
499: public void prepareRow(SubRequest subRequest,
500: MOTableRow changeSet) {
501: OID tdomain = (OID) getResultingValue(
502: idxSnmpTargetAddrTDomain, changeSet);
503: OctetString taddress = (OctetString) getResultingValue(
504: idxSnmpTargetAddrTAddress, changeSet);
505: if (tdomain != null) {
506: TDomainAddressFactory factory = (TDomainAddressFactory) supportedAddressClasses
507: .get(tdomain);
508: if ((factory == null)
509: || (!factory.isValidAddress(tdomain, taddress))) {
510: subRequest
511: .getStatus()
512: .setErrorStatus(
513: SnmpConstants.SNMP_ERROR_INCONSISTENT_VALUE);
514: }
515: } else if (taddress != null) {
516: subRequest.getStatus().setErrorStatus(
517: SnmpConstants.SNMP_ERROR_INCONSISTENT_VALUE);
518: }
519: }
520:
521: public Address getAddress() {
522: OID tdomain = (OID) getValue(idxSnmpTargetAddrTDomain);
523: TDomainAddressFactory factory = (TDomainAddressFactory) supportedAddressClasses
524: .get(tdomain);
525: if (factory != null) {
526: OctetString addr = (OctetString) getValue(idxSnmpTargetAddrTAddress);
527: return factory.createAddress(tdomain, addr);
528: }
529: return null;
530: }
531:
532: public OctetString getTAddress(Address address) {
533: OID tdomain = (OID) getValue(idxSnmpTargetAddrTDomain);
534: TDomainAddressFactory factory = (TDomainAddressFactory) supportedAddressClasses
535: .get(tdomain);
536: OID domain = factory.getTransportDomain(address);
537: if (!tdomain.equals(domain)) {
538: return null;
539: }
540: return factory.getAddress(address);
541: }
542:
543: public Target getTarget(OctetString contextEngineID,
544: OctetString contextName) {
545: Address addr = getAddress();
546: OctetString addrParams = (OctetString) getValue(idxSnmpTargetAddrParams);
547: OID paramsIndex = addrParams.toSubIndex(true);
548: MOTableRow paramsRow = snmpTargetParamsEntryModel
549: .getRow(paramsIndex);
550: if (paramsRow == null) {
551: return null;
552: }
553: Target t;
554: if (paramsRow.getValue(idxSnmpTargetParamsMPModel).toInt() == MPv3.ID) {
555: t = new UserTarget(addr, (OctetString) paramsRow
556: .getValue(idxSnmpTargetParamsSecurityName),
557: contextEngineID.getValue(), paramsRow.getValue(
558: idxSnmpTargetParamsSecurityLevel)
559: .toInt());
560: } else {
561: OctetString community = (OctetString) paramsRow
562: .getValue(idxSnmpTargetParamsSecurityName);
563: if (coexistenceProvider != null) {
564: community = coexistenceProvider.getCommunity(
565: community, contextEngineID, contextName);
566: if (community == null) {
567: return null;
568: }
569: }
570: t = new CommunityTarget(addr, community);
571: }
572: t.setRetries(getValue(idxSnmpTargetAddrRetryCount).toInt());
573: t
574: .setTimeout(getValue(idxSnmpTargetAddrTimeout)
575: .toInt() * 10);
576: t.setVersion(paramsRow.getValue(idxSnmpTargetParamsMPModel)
577: .toInt());
578: return t;
579: }
580: }
581:
582: // Value Validators
583:
584: /**
585: * The <code>SnmpTargetParamsMPModelValidator</code> implements the value validation
586: * for <code>SnmpTargetParamsMPModel</code>.
587: */
588: class SnmpTargetParamsMPModelValidator implements
589: MOValueValidationListener {
590:
591: public void validate(MOValueValidationEvent validationEvent) {
592: Variable newValue = validationEvent.getNewValue();
593: int v = ((Integer32) newValue).getValue();
594: if (session.getMessageProcessingModel(v) == null) {
595: validationEvent
596: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_VALUE);
597: return;
598: }
599: //--AgentGen BEGIN=snmpTargetParamsMPModel::validate
600: //--AgentGen END
601: }
602: }
603:
604: /**
605: * The <code>SnmpTargetParamsSecurityModelValidator</code> implements the value validation
606: * for <code>SnmpTargetParamsSecurityModel</code>.
607: */
608: static class SnmpTargetParamsSecurityModelValidator implements
609: MOValueValidationListener {
610:
611: public void validate(MOValueValidationEvent validationEvent) {
612: //--AgentGen BEGIN=snmpTargetParamsSecurityModel::validate
613: Variable newValue = validationEvent.getNewValue();
614: switch (((Integer32) newValue).getValue()) {
615: case SecurityModel.SECURITY_MODEL_USM: {
616: if (SecurityModels.getInstance().getSecurityModel(
617: (Integer32) newValue) == null) {
618: validationEvent
619: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_VALUE);
620: return;
621: }
622: break;
623: }
624: default:
625: break;
626: }
627: //--AgentGen END
628: }
629: }
630:
631: /**
632: * The <code>SnmpTargetAddrTDomainValidator</code> implements the value validation
633: * for <code>SnmpTargetAddrTDomain</code>.
634: */
635: class SnmpTargetAddrTDomainValidator implements
636: MOValueValidationListener {
637:
638: public void validate(MOValueValidationEvent validationEvent) {
639: Variable newValue = validationEvent.getNewValue();
640: //--AgentGen BEGIN=snmpTargetAddrTDomain::validate
641: if (newValue instanceof OID) {
642: OID tdomain = (OID) newValue;
643: if (!supportedAddressClasses.containsKey(tdomain)) {
644: validationEvent
645: .setValidationStatus(SnmpConstants.SNMP_ERROR_BAD_VALUE);
646: }
647: } else {
648: validationEvent
649: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_TYPE);
650: }
651: //--AgentGen END
652: }
653: }
654:
655: /**
656: * The <code>SnmpTargetAddrTAddressValidator</code> implements the value
657: * validation for <code>SnmpTargetAddrTAddress</code>.
658: */
659: static class SnmpTargetAddrTAddressValidator implements
660: MOValueValidationListener {
661:
662: public void validate(MOValueValidationEvent validationEvent) {
663: Variable newValue = validationEvent.getNewValue();
664: OctetString os = (OctetString) newValue;
665: if (!(((os.length() >= 1) && (os.length() <= 255)))) {
666: validationEvent
667: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_LENGTH);
668: return;
669: }
670: //--AgentGen BEGIN=snmpTargetAddrTAddress::validate
671: //--AgentGen END
672: }
673: }
674:
675: /**
676: * The <code>SnmpTargetAddrTimeoutValidator</code> implements the value
677: * validation for <code>SnmpTargetAddrTimeout</code>.
678: */
679: static class SnmpTargetAddrTimeoutValidator implements
680: MOValueValidationListener {
681:
682: public void validate(MOValueValidationEvent validationEvent) {
683: Variable newValue = validationEvent.getNewValue();
684: long v = ((Integer32) newValue).getValue();
685: if (!(((v >= 0L) /*&& (v <= 2147483647L)*/))) {
686: validationEvent
687: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_VALUE);
688: return;
689: }
690: //--AgentGen BEGIN=snmpTargetAddrTimeout::validate
691: //--AgentGen END
692: }
693: }
694:
695: /**
696: * The <code>SnmpTargetAddrRetryCountValidator</code> implements the value validation
697: * for <code>SnmpTargetAddrRetryCount</code>.
698: */
699: static class SnmpTargetAddrRetryCountValidator implements
700: MOValueValidationListener {
701:
702: public void validate(MOValueValidationEvent validationEvent) {
703: Variable newValue = validationEvent.getNewValue();
704: long v = ((Integer32) newValue).getValue();
705: if (!(((v >= 0L) && (v <= 255L)))) {
706: validationEvent
707: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_VALUE);
708: return;
709: }
710: //--AgentGen BEGIN=snmpTargetAddrRetryCount::validate
711: //--AgentGen END
712: }
713: }
714:
715: /**
716: * The <code>SnmpTargetAddrParamsValidator</code> implements the value validation
717: * for <code>SnmpTargetAddrParams</code>.
718: */
719: class SnmpTargetAddrParamsValidator implements
720: MOValueValidationListener {
721:
722: public void validate(MOValueValidationEvent validationEvent) {
723: Variable newValue = validationEvent.getNewValue();
724: OctetString os = (OctetString) newValue;
725: if (!(((os.length() >= 1) && (os.length() <= 32)))) {
726: validationEvent
727: .setValidationStatus(SnmpConstants.SNMP_ERROR_WRONG_LENGTH);
728: return;
729: }
730: //--AgentGen BEGIN=snmpTargetAddrParams::validate
731: OID paramsIndexOID = os.toSubIndex(true);
732: MOTableRow paramsRow = snmpTargetParamsEntryModel
733: .getRow(paramsIndexOID);
734: if (paramsRow == null) {
735: validationEvent
736: .setValidationStatus(SnmpConstants.SNMP_ERROR_INCONSISTENT_VALUE);
737: }
738: //--AgentGen END
739: }
740: }
741:
742: public void incrementCounter(CounterEvent event) {
743: if (event.getOid().equals(snmpUnavailableContexts.getOid())) {
744: ((Counter32) snmpUnavailableContexts.getValue())
745: .increment();
746: event.setCurrentValue(snmpUnavailableContexts.getValue());
747: } else if (event.getOid().equals(snmpUnknownContexts.getOid())) {
748: ((Counter32) snmpUnknownContexts.getValue()).increment();
749: event.setCurrentValue(snmpUnknownContexts.getValue());
750: }
751: }
752:
753: // Enumerations
754:
755: public static final class SnmpTargetParamsSecurityLevelEnum {
756: public static final int noAuthNoPriv = 1;
757: public static final int authNoPriv = 2;
758: public static final int authPriv = 3;
759: }
760:
761: //--AgentGen BEGIN=_CLASSES
762:
763: public void rowChanged(MOTableRowEvent event) {
764: if ((event.getType() == MOTableRowEvent.DELETE)
765: && (event.getRow() instanceof SnmpTargetAddrEntryRow)) {
766: Variable[] vbs = new Variable[event.getRow().size()];
767: vbs[idxSnmpTargetAddrTagList] = new OctetString();
768: MOTableRow dummyRow = new DefaultMOTableRow(event.getRow()
769: .getIndex(), vbs);
770: ((SnmpTargetAddrEntryRow) event.getRow())
771: .updateUserObject(dummyRow);
772: }
773: }
774:
775: /**
776: * Returns the SNMP Target Parameters row for the specified name.
777: * @param paramsName
778: * the name of the parameters set to return.
779: * @return
780: * if the row containing the target parameters if such an entry
781: * exists or <code>null</code> if no such entry exists
782: */
783: public MOTableRow getTargetParamsRow(OctetString paramsName) {
784: if (paramsName == null) {
785: return null;
786: }
787: OID paramsIndex = paramsName.toSubIndex(true);
788: return snmpTargetParamsEntryModel.getRow(paramsIndex);
789: }
790:
791: /**
792: * Returns the SNMP Target Parameters row for the specified name.
793: * @param paramsName
794: * the name of the parameters set to return.
795: * @param activeOnly
796: * if <code>true</code> only an active row will be returned.
797: * @return
798: * if the row containing the target parameters if such an entry
799: * exists or <code>null</code> if no such entry exists
800: */
801: public MOTableRow getTargetParamsRow(OctetString paramsName,
802: boolean activeOnly) {
803: MOTableRow row = getTargetParamsRow(paramsName);
804: if (activeOnly && (row != null)) {
805: if (((Integer32) row.getValue(idxSnmpTargetParamsRowStatus))
806: .getValue() != RowStatus.active) {
807: return null;
808: }
809: }
810: return row;
811: }
812:
813: public DefaultMOTable getSnmpTargetAddrEntry() {
814: return snmpTargetAddrEntry;
815: }
816:
817: public CoexistenceInfoProvider getCoexistenceProvider() {
818: return coexistenceProvider;
819: }
820:
821: public void setCoexistenceProvider(
822: CoexistenceInfoProvider coexistenceProvider) {
823: this .coexistenceProvider = coexistenceProvider;
824: }
825: //--AgentGen END
826:
827: //--AgentGen BEGIN=_END
828: //--AgentGen END
829: }
|