Beispiel #1
0
int
op_begemot(struct snmp_context *ctx, struct snmp_value *value,
    u_int sub, u_int iidx __unused, enum snmp_op op)
{

	switch (op) {

	  case SNMP_OP_GET:
		switch (value->var.subs[sub - 1]) {

		  case LEAF_begemotHrStorageUpdate:
			value->v.uint32 = storage_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrFSUpdate:
			value->v.uint32 = fs_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrDiskStorageUpdate:
			value->v.uint32 = disk_storage_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrNetworkUpdate:
			value->v.uint32 = network_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWInstalledUpdate:
			value->v.uint32 = swins_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWRunUpdate:
			value->v.uint32 = swrun_tbl_refresh;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrPkgDir:
			return (string_get(value, pkg_dir, -1));
		}
		abort();

	  case SNMP_OP_GETNEXT:
		abort();

	  case SNMP_OP_SET:
		switch (value->var.subs[sub - 1]) {

		  case LEAF_begemotHrStorageUpdate:
			ctx->scratch->int1 = storage_tbl_refresh;
			storage_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrFSUpdate:
			ctx->scratch->int1 = fs_tbl_refresh;
			fs_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrDiskStorageUpdate:
			ctx->scratch->int1 = disk_storage_tbl_refresh;
			disk_storage_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrNetworkUpdate:
			ctx->scratch->int1 = network_tbl_refresh;
			network_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWInstalledUpdate:
			ctx->scratch->int1 = swins_tbl_refresh;
			swins_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWRunUpdate:
			ctx->scratch->int1 = swrun_tbl_refresh;
			swrun_tbl_refresh = value->v.uint32;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrPkgDir:
			return (string_save(value, ctx, -1, &pkg_dir));
		}
		abort();

	  case SNMP_OP_COMMIT:
		switch (value->var.subs[sub - 1]) {

		  case LEAF_begemotHrStorageUpdate:
		  case LEAF_begemotHrFSUpdate:
		  case LEAF_begemotHrDiskStorageUpdate:
		  case LEAF_begemotHrNetworkUpdate:
		  case LEAF_begemotHrSWInstalledUpdate:
		  case LEAF_begemotHrSWRunUpdate:
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrPkgDir:
			string_commit(ctx);
			return (SNMP_ERR_NOERROR);
		}
		abort();

	  case SNMP_OP_ROLLBACK:
		switch (value->var.subs[sub - 1]) {

		  case LEAF_begemotHrStorageUpdate:
			storage_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrFSUpdate:
			fs_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrDiskStorageUpdate:
			disk_storage_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrNetworkUpdate:
			network_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWInstalledUpdate:
			swins_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrSWRunUpdate:
			swrun_tbl_refresh = ctx->scratch->int1;
			return (SNMP_ERR_NOERROR);

		  case LEAF_begemotHrPkgDir:
			string_rollback(ctx, &pkg_dir);
			return (SNMP_ERR_NOERROR);
		}
		abort();
	}

	abort();
}
Beispiel #2
0
/*************************************************************
 *
 * System group
 */
int
op_system_group(struct snmp_context *ctx, struct snmp_value *value,
    u_int sub, u_int iidx __unused, enum snmp_op op)
{
	asn_subid_t which = value->var.subs[sub - 1];

	switch (op) {

	  case SNMP_OP_GETNEXT:
		abort();

	  case SNMP_OP_GET:
		break;

	  case SNMP_OP_SET:
		switch (which) {

		  case LEAF_sysDescr:
			if (community != COMM_INITIALIZE)
				return (SNMP_ERR_NOT_WRITEABLE);
			return (string_save(value, ctx, -1, &systemg.descr));

		  case LEAF_sysObjectId:
			if (community != COMM_INITIALIZE)
				return (SNMP_ERR_NOT_WRITEABLE);
			return (oid_save(value, ctx, &systemg.object_id));

		  case LEAF_sysContact:
			return (string_save(value, ctx, -1, &systemg.contact));

		  case LEAF_sysName:
			return (string_save(value, ctx, -1, &systemg.name));

		  case LEAF_sysLocation:
			return (string_save(value, ctx, -1, &systemg.location));
		}
		return (SNMP_ERR_NO_CREATION);

	  case SNMP_OP_ROLLBACK:
		switch (which) {

		  case LEAF_sysDescr:
			string_rollback(ctx, &systemg.descr);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysObjectId:
			oid_rollback(ctx, &systemg.object_id);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysContact:
			string_rollback(ctx, &systemg.contact);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysName:
			string_rollback(ctx, &systemg.name);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysLocation:
			string_rollback(ctx, &systemg.location);
			return (SNMP_ERR_NOERROR);
		}
		abort();

	  case SNMP_OP_COMMIT:
		switch (which) {

		  case LEAF_sysDescr:
			string_commit(ctx);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysObjectId:
			oid_commit(ctx);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysContact:
			string_commit(ctx);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysName:
			string_commit(ctx);
			return (SNMP_ERR_NOERROR);
		  case LEAF_sysLocation:
			string_commit(ctx);
			return (SNMP_ERR_NOERROR);
		}
		abort();
	}

	/*
	 * Come here for GET.
	 */
	switch (which) {

	  case LEAF_sysDescr:
		return (string_get(value, systemg.descr, -1));
	  case LEAF_sysObjectId:
		return (oid_get(value, &systemg.object_id));
	  case LEAF_sysUpTime:
		value->v.uint32 = get_ticks() - start_tick;
		break;
	  case LEAF_sysContact:
		return (string_get(value, systemg.contact, -1));
	  case LEAF_sysName:
		return (string_get(value, systemg.name, -1));
	  case LEAF_sysLocation:
		return (string_get(value, systemg.location, -1));
	  case LEAF_sysServices:
		value->v.integer = systemg.services;
		break;
	  case LEAF_sysORLastChange:
		value->v.uint32 = systemg.or_last_change;
		break;
	}
	return (SNMP_ERR_NOERROR);
}