mgmt_mmp.c revision cee0fb94c0d4227de0a00efc162fb2739844b641
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include "mms_mgmt.h"
#include "mgmt_acsls.h"
#include "mmp_defs.h"
#include "mgmt_sym.h"
#include "mgmt_util.h"
/*
* This file contains the following functionality:
* 1. parse MMP responses
* 2. error handling of MM communication
*/
static char *mgmt_cvt_mmp_to_user(char *in);
typedef struct {
char *mmp_opt;
char *public_opt;
/* those with NULL equivalents will not be returned to the caller */
static map_opt_names optmap[] = {
{"CartridgeTypeName", O_VOLTYPE},
{"CartridgeTypeNumberSides", "sides"},
{"CartridgeTypeMediaLength", O_SIZE},
{"CartridgeTypeMediaType", "purpose"},
{"CartridgeStatus", "status"},
{"CartridgeDriveOccupied", "loaded-in-drive"},
{"MaxUseCount", "max-use-count"},
{"CartridgeShapeName", O_MTYPE},
{"Side1Name", NULL},
{"CartridgeTypeSize", NULL},
{"CartridgeID", NULL},
{"CartridgePCL", "volid"},
{"CartridgeState", "state"},
{"CartridgeGroupName", O_MPOOL},
{"CartridgeTimeCreated", "created"},
{"CartridgeTimeMountedLast", "last-mounted"},
{"CartridgeTimeMountedTotal", "total-mount-time"},
{"CartridgeNumberMounts", "num-mounts"},
{"CartridgeWriteProtected", "write-protected"},
{"CartridgeNumberVolumes", NULL},
{"CartridgeMediaError", "media-error"},
{"CartridgeBytesRead", "bytes-read"},
{"CartridgeBytesWritten", "bytes-written"},
{"CartridgeRecovededReads", NULL},
{"CartridgeRecovededWrites", NULL},
{"CartridgeUnrecovededReads", NULL},
{"CartridgeUnrecovededWrites", NULL},
{"LibraryName", O_MMSLIB},
{"CartridgeMountPoint", "mountpt"},
{"CartridgePath", "path"},
{"Administrator", NULL},
{"AttendanceMode", O_ATTENDED},
{"SystemLogLevel", O_LOGLEVEL},
{"SystemAcceptLevel", NULL},
{"SystemLogFile", O_LOGFILE},
{"SystemMessageLimit", NULL},
{"SystemMessageCount", NULL},
{"SystemRequestLimit", NULL},
{"SystemRequestCount", "num-oper-requests"},
{"SystemSyncLimit", NULL},
{"SystemDCALimit", NULL},
{"SystemDCACount", NULL},
{"ClearDriveAtLMConfig", NULL},
{"AskClearDriveAtLMConfig", NULL},
{"PreemptReservation", NULL},
{"MessageLevel", O_MSGLEVEL},
{"TraceLevel", O_TRACELEVEL},
{"TraceFileSize", O_TRACESZ},
{"SocketFdLimit", O_NUMSOCKET},
{"SystemLogFileSize", "log-size"},
{"SystemName", O_NAME},
{"SystemInstance", NULL},
{"UnloadDelayTime", O_UNLOADTM},
{"DefaultBlocksize", NULL},
{"SystemDiskMountTimeout", O_DKTIMEOUT},
{"WatcherStartsLimit", O_NUMRESTART},
{"DriveRecordRetention", NULL},
{"DriveName", O_NAME},
{"DriveGroupName", NULL},
{"DrivePriority", NULL},
{"DriveShapeName", NULL},
{"DriveDisabled", "disabled"},
{"DriveBroken", "broken"},
{"DriveStateSoft", "DM state"},
{"DriveStateHard", "state"},
{"DriveTimeCreated", "create-time"},
{"DriveTimeMountedLast", "last-mount"},
{"DriveTimeMountedTotal", "total-mount-time"},
{"DriveNumberMounts", "num-mounts"},
{"DriveNumberMountsSinceCleaning", "mounts-since-clean"},
{"DriveLibraryAccessible", NULL},
{"DriveLibraryOccupied", NULL},
{"DriveNeedsCleaning", "needs-cleaning"},
{"MaxMounts", NULL},
{"ExclusiveAppName", NULL},
{"ReserveDrive", O_RESERVE},
{"DefaultBlocksize", "blocksize"},
{"DriveSerialNum", O_SERIALNO},
{"DriveOnline", O_ONLINE},
{"DriveType", O_TYPE},
{"LibraryDisabled", "disabled"},
{"LibraryBroken", "broken"},
{"LibraryStateHard", "state"},
{"LibraryStateSoft", "LM state"},
{"LibraryOnline", O_ONLINE},
{"LibraryType", O_TYPE},
{"LibraryIP", O_ACSHOST},
{"LibraryACS", O_ACSNUM},
{"LibraryLSM", O_LSMNUM},
{"LibrarySerialNum", O_SERIALNO},
{"RequestID", "request-id"},
{"RequestingTaskID", NULL},
{"RequestingClient", "requestor"},
{"RequestingInstance", NULL},
{"RequestingClientType", "requestor-type"},
{"RequestPriority", "priority"},
{"RequestState", O_OBJSTATE},
{"RequestText", "description"},
{"AcceptingSessionID", NULL},
{"ResponseText", O_RESPTXT},
{"RequestTimeCreated", "create-time"},
{"RequestTimeAccepted", "accept-time"},
{"RequestTimeResponded", "response-time"},
{"ApplicationName", O_NAME},
{"SignatureAlgorithm", NULL},
{"AllowRemoteMount", NULL},
{"BypassVerify", NULL},
{"ReadWriteMode", NULL},
{"ValidateFileName", O_VALIDATEFN},
{"ValidateVolumeID", O_VALIDATEVOL},
{"ValidateExpirationDate", O_VALIDATEEXP},
{"SwitchLabel", NULL},
{"WriteOverExistingData", O_OVERWRITEEXT},
{"Retention", O_RETENTION},
};
int
mms_client_handle_rsp(void *rsp)
{
int rc;
int class;
int code;
char *msg;
int rsptype;
if (!rsp) {
return (MMS_MGMT_NOARG);
}
switch (rsptype) {
case MMS_API_RSP_UNACC:
break;
case MMS_API_RSP_ACC:
rc = 0;
break;
case MMS_API_RSP_FINAL:
rc = 0;
break;
case MMS_API_RSP_FINAL_ERR:
"Command received an error response");
if (rc != MMS_API_OK) {
break;
}
if (msg) {
}
if (code == MMS_EDATABASE) {
"duplicate key"))||
"already exists"))) {
"still referenced")) {
}
}
} else {
}
break;
case MMS_API_RSP_FINAL_CANC:
"Command received a cancelled response");
break;
default:
rsptype);
break;
}
if (lrsp->mms_rsp_str) {
}
return (rc);
}
/*
* Parse the response to a report LIBRARY request and fill the mms_acslib_t
* structure
*
* "LibraryName" "library1" "LibraryDisabled" "false" "LibraryBroken" "false"
* "LMName" "lm1" "LibraryStateHard" "unknown" "LibraryStateSoft" "ready"
* "LibraryOnline" "true" "LibraryType" "L180" "LibraryConnection" "network"
* "LibraryIP" "nws-nsh-54-94.east" "LibraryPath" "" "LibraryACS" "0"
*/
void
{
if (!lib) {
return;
}
/* LibraryName */
}
}
/* LibraryType */
}
}
/* LibraryIP */
}
}
/* LibraryACS */
}
}
}
}
/* LibrarySerialNum */
&lasts);
}
}
}
/*
* parse the LIBRARY LM response which has a sequence of library objects and
* the LM(s) for each library
*/
int
{
if (!rsp || !acslib_list) {
return (-1);
}
return (-1);
}
/*
* Multiple attrlist clauses in this text clause:
* First attrlist describes the library
* Subsequent attrlist describes the LM(s) for the drive
*/
if (first) {
} else {
}
}
}
}
return (0);
}
/*
* parse the MMP response to a LM report and fill the values in mms_lm_t
*
* The response are position dependent.
* "LibraryName" "virt-library" "LMName" "virt-lm" "LMHost" "10.1.170.163"
* "LMTargetLibrary" "" "LMTargetPath" "" "LMTargetHost" "muddy-mn"
* "LMPassword" "" "LMMessageLevel" "error" "LMStateHard" "ready"
* "LMStateSoft" "ready" "LMDisabled" "false" "TraceLevel" "debug"
* "TraceFileSize" "10M"
*/
void
{
return;
}
/* LMName */
}
}
/* LMTargetHost */
}
}
/* Flags - LMStateHard, LMStateSoft, LMDisabled */
}
int
{
return (-1);
}
}
return (0);
}
/*
* parse the MMP response to a DM report and fill the values in mms_dm_t
*
* "DMName" "virt-dm1" "DriveName" "virt-drive0" "DMHost" "10.1.170.163"
* "DMTargetHost" "muddy-mn" "DMPassword" "" "DMMessageLevel" "error"
* "DMStateHard" "ready" "DMStateSoft" "ready" "DMDisabled" "false"
* "TraceLevel" "debug" "TraceFileSize" "10M"
*/
void
{
return;
}
/* DMName */
}
}
/* DMTargetHost */
}
}
/* Flags - DMStateHard, DMStateSoft, DMDisabled */
}
int
{
return (-1);
}
break;
}
}
return (0);
}
/*
* Parse drive attributes from the response
*
* "DriveName" "drive1" "DriveGroupName" "LTO" "DrivePriority" "1000"
* "DMName" "" "DriveShapeName" "LTO3" "DriveDisabled" "false"
* "DriveBroken" "false" "DriveStateSoft" "ready" "DriveStateHard" "unloaded"
* "DriveTimeCreated" "2007 09 13 12 47 58 328" "DriveTimeMountedLast"
* "2007 09 20 15 33 54 037" "DriveTimeMountedTotal" "0000 00 00 00 00 00 000"
* "DriveNumberMounts" "3" "DriveNumberMountsSinceCleaning" "3" "LibraryName"
* "library1" "BayName" "panel 0" "DriveLibraryAccessible" "true"
* "DriveLibraryOccupied" "false" "CartridgePCL" "" "DriveNeedsCleaning" "false"
* "MaxMounts" "0" "ExclusiveAppName" "none" "ReserveDrive" "yes"
* "DefaultBlocksize" "262144" "DriveGeometry" "0,0,0,1" "DriveSerialNum"
* "1210013554" "DriveOnline" "true"
*
*/
void
{
if (!node || !d) {
return;
}
/* DriveName */
}
}
/* DriveGroupName (future) */
/* DrivePriority */
}
}
/* Flags - DriveDisabled */
d->flags |= MMS_ST_DRIVE_DISABLED;
}
}
}
/* Flags - DriveBroken */
d->flags |= MMS_ST_DRIVE_BROKEN;
}
}
}
/* Flags - DriveStateSoft */
d->flags |= MMS_ST_DRIVE_READY;
d->flags |= MMS_ST_DRIVE_INUSE;
}
}
}
/* Flags - DriveStateHard */
d->flags |= MMS_ST_DRIVE_LOADED;
== 0) {
d->flags |= MMS_ST_DRIVE_LOADING;
== 0) {
d->flags |= MMS_ST_DRIVE_UNLOADING;
== 0) {
d->flags |= MMS_ST_DRIVE_UNLOADED;
}
}
}
/* LibraryName */
}
}
/* More Flags - DriveLibraryAccessible, DriveLibraryOccupied */
MMS_PN_STRING, &lasts);
d->flags |= MMS_ST_DRIVE_INACCESSIBLE;
}
}
}
MMS_PN_STRING, &lasts);
d->flags |= MMS_ST_DRIVE_OCCUPIED;
}
}
}
/* CartridgePCL - Media in Drive */
/* More Flags - DriveNeedsCleaning */
MMS_PN_STRING, &lasts);
d->flags |= MMS_ST_DRIVE_RCLEANING;
== 0) {
d->flags |= MMS_ST_DRIVE_ACLEANING;
== 0) {
d->flags |= MMS_ST_DRIVE_MCLEANING;
}
}
}
/* DefaultBlocksize */
MMS_PN_STRING, &lasts);
}
}
/* DriveSerialNum */
}
}
/* More Flags - DriveOnline (not in MM spec ?) */
d->flags |= MMS_ST_DRIVE_OFFLINE;
}
}
}
/* DriveType */
}
}
}
/*
* Parse the MMP response consisting of a sequence of drive objects and dm
* objects for that drive. Convert the response to a list of mms_drive_t
* This response is in request to a report DRIVE DM
*
* The response is made up a series of name value pairs, these name value
* entries are positional and the parsing function saves a pointer to the
* following byte, from which the next search for an attribute begins. So the
* attributes have to be parsed in a predetermined order. The response is
* given below for attribute order purposes.
*
*/
int
{
if (!rsp || !drive_list) {
return (-1);
}
return (-1);
}
/*
* Multiple attrlist clauses in this text clause:
* First attrlist describes the drive
* Subsequent attrlist describes the DM(s) for the drive
*/
if (first) {
} else {
dm);
}
}
}
}
return (0);
}
/*
* The function mmp_build() builds the command syntax using the MMP language.
* All requests to the MM, including access to media, device management
* functions, routine operational functions and MMS administration are done
* using the MMP protocol.
*
* The MMP is made up of command type, object type and its attributes. MMP
* supports a rich range of commands which fall into several different
* categories such as attribute, cancel, create, deallocate, delete, goodbye,
* locale, privilege, rename, show, accept, begin-end, cpattribute, cpscan,
* cpshow, cpreset, eject, inject, mount, move, release, respond, shutdown
* and unmount. The mmp_build() function only supports the attribute, create,
* delete and show commands at this time.
*
* The MMS defines more than 40 types of objects that make up a media
* environment. This funtion however builds the MMP for the library, lm
* drive, dm, drivegroup, drivegroupapplication, slottype, cartridge,
* cartridgegroup, and cartridgegroupapplication only.
*/
/*
* The MM should create the SLOTTYPE and CARTRIDGETYPE objects by default for
* all supported media. Sadly, they're not yet doing CARTRIDGETYPE for reasons
* that escape me.
*/
/*
* Processes a single clause, that may have multiple attr lists
*/
int
{
int st = 0;
char *val;
int lcnt = 0;
char buf[1024];
return (MMS_MGMT_NOARG);
}
return (EINVAL);
}
}
!= NULL) {
if (!attrs) {
break;
}
} else {
if (st != 0) {
break;
}
&alast);
}
}
if (st == 0) {
if (st != 0) {
"unknown_%d", ++lcnt);
}
}
if (st != 0) {
break;
}
}
return (st);
}
/*
* If useropt = B_TRUE, convert the MMP keys to public keys
*/
static int
{
int st;
char *namep;
char *valp;
return (MMS_MGMT_NOARG);
}
if (st != 0) {
return (st);
}
for (;;) {
if (!name) {
break;
}
if (!val) {
continue;
}
if (useropt) {
}
if (namep) {
}
}
}
return (st);
}
static char *
mgmt_cvt_mmp_to_user(char *in)
{
int i;
if (!in) {
return (NULL);
}
break;
}
}
return (out);
}
int
{
return (MMS_MGMT_NOARG);
}
*count = 0;
return (EINVAL);
}
return (0);
/* this label required for the MMS_PN_LOOKUP macro */
return (1);
}