File dmsvsma.x of Package snipl

 
/*
 * COPYRIGHT -
 *
 *   THIS MODULE IS "RESTRICTED MATERIALS OF IBM"
 *   5739-A03 (C) COPYRIGHT IBM CORP. - 2003
 *   LICENSED MATERIALS - PROPERTY OF IBM
 *   ALL RIGHTS RESERVED.
 *
 * STATUS - z/VM   Version 4, Release 4.0
 */
 
/* Start of data types */
 
/*
 * Return Code values
 */
typedef int Return_Code;
const RC_OK                =   0; /* Request Successful */                                             /*@SM088P2*/
const RCERR_TOKEN          =   8; /* Session Token Not Valid */                                        /*@SM088P2*/
const RCERR_NO_STORAGE     =  16; /* Not enough storage; try again with smaller input buffer */        /*@SM088P2*/
const RCERR_CONFLICTING    =  23; /* Conflicting Parameter Data */                                     /*@SM278P2*/
const RCERR_SYNTAX         =  24; /* Syntax Error in Function Parameter */                             /*@SM088P2*/
const RCERR_FILE_NOT_FOUND =  28; /* Namelist File Not Found */                                        /*@SM088P2*/
const RCERR_FILE_CANNOT_BE_UPDATED = 36; /* Namelist File Cannot Be Updated */                         /*@SM088P2*/
const RC_IS_AUTHORIZED     = 100; /* Authorization request successful */                               /*@SM088P2*/
const RCERR_AUTH           = 100; /* Request Not Authorized By External Security Manager */            /*@SM088P2*/
const RCERR_NO_AUTHFILE    = 104; /* Authorization File Not Found */                                   /*@SM088P2*/
const RCERR_AUTHFILE_RO    = 106; /* Authorization File Cannot Be Updated */                           /*@SM088P2*/
const RCERR_EXISTS         = 108; /* Authorization File Entry Already Exists */                        /*@SM088P2*/
const RCERR_NO_ENTRY       = 112; /* Authorization File Entry Does Not Exist */                        /*@SM088P2*/
const RCERR_USER_PW_BAD    = 120; /* Authentication Error; Userid or Password Not Valid */             /*@SM088P2*/
const RCERR_PW_EXPIRED     = 128; /* Authentication Error; Password Expired */                         /*@SM088P2*/
const RCERR_DMSESM         = 188; /* Internal Server Error; ESM Failure */                             /*@SM088P2*/
const RCERR_DMSPWCHK       = 192; /* Internal Server Error; Cannot Authenticate User/Password */       /*@SM088P2*/
const RCERR_DMSCSL         = 196; /* Internal Server Error; Callable Services Failure */               /*@SM088P2*/
const RCERR_IMAGEOP        = 200; /* Image Operation Error */                                          /*@SM088P2*/
const RCERR_IMAGEDEVU      = 204; /* Image Device Usage Error */                                       /*@SM088P2*/
const RCERR_IMAGEDISKU     = 208; /* Image Disk Usage Error */                                         /*@SM088P2*/
const RCERR_IMAGECONN      = 212; /* Active Image Connectivity Definition Error */                     /*@SM088P2*/
const RCERR_INTERNAL       = 396; /* Internal System Error - Product Specific Return Code */           /*@SM088P2*/
const RCERR_IMAGE_NAME     = 400; /* Image Name Error */                                               /*@SM088P2*/
const RCERR_IMAGEDEF       = 400; /* Image Definition Error */                                         /*@SM088P2*/
const RCERR_IMAGEDEVD      = 404; /* Image Device Definition Error */                                  /*@SM088P2*/
const RCERR_IMAGEDISKD     = 408; /* Image Disk Definition Error */                                    /*@SM088P2*/
const RCERR_IMAGECONND     = 412; /* Image Connectivity Definition Error */                            /*@SM088P2*/
const RCERR_PROTODEF       = 416; /* Prototype Definition Error */                                     /*@SM088P2*/
const RCERR_POLICY_PW      = 444; /* Password Policy Error */                                          /*@SM088P2*/
const RCERR_POLICY_ACCT    = 448; /* Account Number Policy Error */                                    /*@SM088P2*/
const RCERR_DM             = 500; /* Directory Manager Error */                                        /*@SM088P2*/
const RCERR_LIST_DM        = 504; /* Directory Manager List Error */                                   /*@SM284P2*/
const RCERR_ASYNC_DM       = 592; /*                         */                                        /*@SM088P2*/
const RCERR_INTERNAL_DM    = 596; /* Internal Directory Manager Error */                               /*@SM088P2*/
const RCERR_SHSTOR         = 600; /* Error from Shared_Storage functions*/                             /*@SM088P2*/
 
/*
 * Reason Code values
 */
typedef int Reason_Code;                                                                               /*@SM088P2*/
const RS_NONE              =   0; /* Request Successful */                                             /*@SM088P2*/
const RS_DEFERRED_SERVER   =   4; /* Authorization Deferred to Server */                               /*@SM088P2*/
const RS_EXISTS            =   4; /* With RC=204, Device already exists  */                            /*@SM278P2*/
const RS_IN_USE            =   4; /* Image Disk Already In Use */                                      /*@SM088P2*/
const RS_NO_PARTNER        =   4; /* Partner Image Not Found */                                        /*@SM088P2*/
const RS_NO_UPDATES        =   4; /* Directory Manager Is Not Accepting Updates */                     /*@SM088P2*/
const RS_NOT_FOUND         =   4; /* Image Not Found */                                                /*@SM088P2*/
const RS_ALREADY_ACTIVE    =   8; /* Image Already Active */                                           /*@SM088P2*/
const RS_AUTHERR_CONNECT   =   8; /* Image Not Authorized To Connect */                                /*@SM088P2*/
const RS_AUTHERR_ESM       =   8; /* Request Not Authorized By External Security Manager */            /*@SM088P2*/
const RS_BAD_RANGE         =   8; /* bad page range */                                                 /*@SM278P2*/
const RS_NAME_EXISTS       =   8; /* Image Name Already Defined */                                     /*@SM088P2*/
const RS_NOT_AVAILABLE     =   8; /* Directory Manager Is Not Available */                             /*@SM088P2*/
const RS_NOT_DEFINED       =   8; /* Image Device Not Defined */                                       /*@SM088P2*/
const RS_NOT_EXIST         =   8; /* With  RC=204, Device does not exist   */                          /*@SM278P2*/
const RS_NOT_IN_USE        =   8; /* Image Disk Not In Use */                                          /*@SM088P2*/
const RS_OFFLINE           =   8; /* Request Successful; Object Directory Offline */                   /*@SM088P2*/
const RS_AUTHERR_CONNECT   =   8; /* With  RC=212, Not authorized to conect*/                          /*@SM278P2*/
const RS_AUTHERR_DM        =  12; /* Request Not Authorized By Directory Manager */                    /*@SM088P2*/
const RS_BUSY              =  12; /* Image Device Is Busy */                                           /*@SM088P2*/
const RS_LAN_NOT_EXIST     =  12; /* Lan Does Not Exist */                                             /*@SM088P2*/
const RS_LOCKED            =  12; /* Image Definition Is Locked */                                     /*@SM088P2*/
const RS_NEW_LIST          =  12; /* Request Successful; New List Created */                           /*@SM088P2*/
const RS_NOT_ACTIVE        =  12; /* With  RC=200, Image not active*/                                  /*@SM278P2*/
const RS_NOT_LOGGED_ON     =  12; /* user not logged on */                                             /*@SM278P2*/
const RS_AUTHERR_SERVER    =  16; /* Request Not Authorized By Server */                               /*@SM088P2*/
const RS_BEING_DEACT       =  16; /* Image Being Deactivated */                                        /*@SM088P2*/
const RS_CANNOT_DELETE     =  16; /* Image Definition Can Not be Deleted */                            /*@SM088P2*/
const RS_CANNOT_SHARE      =  16; /* Image Disk Cannot Be Shared As Requested */                       /*@SM088P2*/
const RS_LIST_DESTROYED    =  16; /* Request Successful; No More Entries, List Destroyed */            /*@SM088P2*/
const RS_NO_MATCH          =  16; /* Parameters do not match existing directory statement */           /*@SM088P2*/
const RS_NO_SHARING        =  16; /* Image Disk Sharing Not Allowed By Target Image Definition */      /*@SM088P2*/
const RS_NOSAVE            =  16; /* could not save segment    */                                      /*@SM088P2*/
const RS_IS_CONNECTED      =  20; /* With  RC=204, Device already connected*/                          /*@SM278P2*/
const RS_NOT_AUTHORIZED    =  20; /* not authorized for function*/                                     /*@SM088P2*/
const RS_OWNER_NOT_ACTIVE  =  20; /* Owner of requested LAN is not active */                           /*@SM088P2*/
const RS_SHARE_DIFF_MODE   =  20; /* Image Disk Shared In Different Mode */                            /*@SM088P2*/
const RS_VMLAN_CREATED     =  20; /* Request Successful; New Virtual Network LAN Created */            /*@SM088P2*/
const RS_SYNTAX_CONFLICT   =  23; /* Conflicting parameter data from Parser*/                          /*@SM377Z6*/
const RS_CONFLICTING_PARMS =  24; /* Conflicting storage parameters        */                          /*@SM377Z6*/
const RS_LAN_NAME_EXISTS   =  24; /* Same name as an existing LAN was used */                          /*@SM088P2*/
const RS_LIST_NOT_FOUND    =  24; /* List Not Found */                                                 /*@SM088P2*/
const RS_NO_SPACE          =  24; /* Requested Image Disk Space Not Available */                       /*@SM088P2*/
const RS_NOT_LOCKED        =  24; /* Image Name Is Not Locked */                                       /*@SM088P2*/
const RS_TYPE_NOT_SAME     =  24; /* Image Device Type Not Same As Source */                           /*@SM088P2*/
const RS_VMLAN_REMOVED     =  24; /* Request Successful; Virtual Network LAN Removed */                /*@SM088P2*/
const RS_DEV_INCOMPATIBLE  =  28; /* With  RC=212, Device not correct type */                          /*@SM278P2*/
const RS_NOT_ALL           =  28; /* Some Images In List Not Activated */                              /*@SM088P2*/
const RS_PW_NEEDED         =  28; /* Image Disk Does Not Have Required Password */                     /*@SM088P2*/
const RS_SEGMENT_NOT_FOUND =  28; /* Shared Storage Segment Not found  */                              /*@SM172Z6*/
const RS_SIZE_NOT_SAME     =  28; /* Image Device Size Not Same As Source */                           /*@SM088P2*/
const RS_BAD_PW            =  32; /* Incorrect Password Specified for Image Disk */                    /*@SM088P2*/
const RS_NOT_CONNECTED     =  32; /* With  RC=212, Device not connected    */                          /*@SM278P2*/
const RS_NOT_IN_LIST       =  32; /* Name was not in List */                                           /*@SM088P2*/
const RS_SOME_NOT_DEACT    =  32; /* Some Images In List Not De-Activated */                           /*@SM088P2*/
const RS_NAME_IN_LIST      =  36; /* Name is already in List */                                        /*@SM088P2*/
const RS_SOME_NOT_RECYC    =  36; /* Some Images In List Not Re-Cycled */                              /*@SM088P2*/
const RS_TIME_NOT_VALID    =  36; /* Force Time for Deact. not valid   */                              /*@SM694Z6*/
const RS_VSWITCH_EXISTS    =  36; /* With  RC=212, Vswitch already exists  */                          /*@SM278P2*/
const RS_VSWITCH_CREATED   =  40; /* With  RC=0, Vswitch was created */                                /*@SM278P2*/
const RS_VSWITCH_NOT_EXISTS=  40; /* With  RC=212, Vswitch does not exist  */                          /*@SM278P2*/
const RS_ALREADY_AUTH      =  44; /* With  RC=212, Image already granted   */                          /*@SM278P2*/
const RS_VSWITCH_REMOVED   =  44; /* With  RC=0, Vswitch was removed */                                /*@SM278P2*/
const RS_UNKNOWN           =  96; /* Connection request failed but cannot determine why */             /*@SM088P2*/
const RS_ASYNC_OP_SUCCEEDED= 100;                                                                      /*@SM088P2*/
const RS_ASYNC_OP_IN_PROGRESS=104;                                                                     /*@SM088P2*/
const RS_ASYNC_OP_FAILED   = 108;                                                                      /*@SM088P2*/
const RS_CLASS_S_ALREADY_DEFINED = 299;  /* defseg class s file exists */                              /*@SM172Z6*/
const RS_CSLLIB_NOT_FOUND  =1136; /* DMSVSLIB CSLLIB was not found */                                  /*@SM215P2*/
/* End of Reason_Code values */
 
typedef unsigned int Data_Security_Erase_Values;
const DSEV_USE_DEFAULT_CONFIG = 0;
const DSEV_UNUSED = 1;
const DSEV_OVERRIDE_DEFAULT_NO_ERASE = 2;
const DSEV_OVERRIDE_DEFAULT_ERASE = 3;
 
typedef unsigned int Image_Instance;
const II_DYNAMIC = 1;
const II_STATIC = 2;
const II_ALL = 3;
 
typedef unsigned int Debug_Component_Values;
const DCV_RPC_SERVER = 1;
const DCV_DIRECTORY_MANAGER = 2;
const DCV_SYSTEM_FUNCTIONS = 3;
 
typedef unsigned int Debug_Level_Values;
const DLV_LEVEL0 = 0;
const DLV_LEVEL1 = 1;
const DLV_LEVEL2 = 2;
const DLV_LEVEL3 = 3;
 
/* charNA definition */
#ifdef __VM__
#ifdef RPC_HDR
%/* For VM, the charNA type cannot be opaque.  Instead, we */
%/* define the charNA type to be what RPCGEN gives us.     */
%/* Then later we define the xdr_charNA() routine also to  */
%/* be the same as what RPCGEN would give us, plus the     */
%/* translation to and from ascii to ebcdic and visa versa.*/
%typedef struct {
%    u_int charNA_len;
%    char *charNA_val;
%} charNA;
%bool_t xdr_charNA();
#endif /* RPC_HDR */
#else  /* __VM__ */
/*
 * charNA:
 * The charNA datatype is a sequence of ascii characters that are
 * expected to be ascii over the wire.  If the OS is non-ascii
 * then it needs to convert between the two making sure that the
 * data is sent out in ascii.
 */
typedef opaque charNA<>;
#endif /* __VM__ */
 
typedef opaque Session_Token[8];
 
struct Failing_Images_List {
   string ImageName<>;
   Return_Code ImageReturnCode;
   Reason_Code ImageReasonCode;
   Failing_Images_List *next_entry;
};
 
/* Start of RPC Procedure Definitions */
 
/*
 * LOGIN definitions
 */
struct LOGIN_args {
   string AuthenticatedUserid<>;
   string loginpw<>;
};
 
struct LOGIN_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct LOGIN_resfail {
   Reason_Code rs;
};
 
union LOGIN_res switch (Return_Code rc) {
case RC_OK:
   LOGIN_resok resok;
default:
   LOGIN_resfail resfail;
};
 
/*
 * LOGOUT definitions
 */
struct LOGOUT_args {
   Session_Token SessionToken;
};
 
struct LOGOUT_resok {
   Reason_Code rs;
};
 
struct LOGOUT_resfail {
   Reason_Code rs;
};
 
union LOGOUT_res switch (Return_Code rc) {
case RC_OK:
   LOGOUT_resok resok;
default:
   LOGOUT_resfail resfail;
};
 
/*
 * MODIFY_SESSION_TIMEOUT_INTERVAL definitions
 */
struct MODSESSIONTIMEINTERVAL_args {
   Session_Token SessionToken;
   unsigned int New_Timeout_Interval;
};
 
struct MODSESSIONTIMEINTERVAL_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct MODSESSIONTIMEINTERVAL_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union MODSESSIONTIMEINTERVAL_res switch (Return_Code rc) {
case RC_OK:
   MODSESSIONTIMEINTERVAL_resok resok;
default:
   MODSESSIONTIMEINTERVAL_resfail resfail;
};
 
/*
 * MODIFY_SERVER_TIMEOUT_INTERVAL definitions
 */
struct MODSERVERTIMEINTERVAL_args {
   Session_Token SessionToken;
   unsigned int New_Timeout_Interval;
   unsigned int New_Timeout_Max;
};
 
struct MODSERVERTIMEINTERVAL_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct MODSERVERTIMEINTERVAL_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union MODSERVERTIMEINTERVAL_res switch (Return_Code rc) {
case RC_OK:
   MODSERVERTIMEINTERVAL_resok resok;
default:
   MODSERVERTIMEINTERVAL_resfail resfail;
};
 
/*
 * QUERY_TIMEOUT_INTERVAL definitions
 */
struct QRYTIMEINTERVAL_args {
   Session_Token SessionToken;
};
 
struct QRYTIMEINTERVAL_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   unsigned int Session_Timeout_Interval;
   unsigned int Session_Time_Remaining;
   unsigned int Server_Timeout_Interval;
   unsigned int Server_Timeout_Max;
};
 
struct QRYTIMEINTERVAL_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union QRYTIMEINTERVAL_res switch (Return_Code rc) {
case RC_OK:
   QRYTIMEINTERVAL_resok resok;
default:
   QRYTIMEINTERVAL_resfail resfail;
};
 
/*
 * VSMAPI_DEBUG Definitions
 */
struct DEBUG_args {
   Session_Token SessionToken;
   Debug_Component_Values DebugComponent;
   Debug_Level_Values DebugLevel;
};
 
struct DEBUG_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct DEBUG_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union DEBUG_res switch (Return_Code rc) {
case RC_OK:
   DEBUG_resok resok;
default:
   DEBUG_resfail resfail;
};
 
/*
 * AUTHORIZATION_LIST_ADD definitions
 */
struct AUTHLISTADD_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string For_ID<>;
   string Function_ID<>;
};
 
struct AUTHLISTADD_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct AUTHLISTADD_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union AUTHLISTADD_res switch (Return_Code rc) {
case RC_OK:
   AUTHLISTADD_resok resok;
default:
   AUTHLISTADD_resfail resfail;
};
 
/*
 * AUTHORIZATION_LIST_REMOVE definitions
 */
struct AUTHLISTREM_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string For_ID<>;
   string Function_ID<>;
};
 
struct AUTHLISTREM_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct AUTHLISTREM_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union AUTHLISTREM_res switch (Return_Code rc) {
case RC_OK:
   AUTHLISTREM_resok resok;
default:
   AUTHLISTREM_resfail resfail;
};
 
/*
 * AUTHORIZATION_LIST_QUERY definitions
 */
struct AUTHLISTQUERY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string For_ID<>;
   string Function_ID<>;
};
 
struct Auth_List_Query_Record {
   string Requesting_Userid<>;
   unsigned int Requesting_List_Indicator;
   string For_Userid<>;
   unsigned int For_List_Indicator;
   string Function_Name<>;
   unsigned int Function_List_Indicator;
   Auth_List_Query_Record *next_entry;
};
 
struct AUTHLISTQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   Auth_List_Query_Record *auth_entries;
};
 
struct AUTHLISTQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union AUTHLISTQUERY_res switch (Return_Code rc) {
case RC_OK:
   AUTHLISTQUERY_resok resok;
default:
   AUTHLISTQUERY_resfail resfail;
};
 
/*
 * NAME_LIST_ADD definitions
 */
struct NAMELISTADD_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string Name<>;
};
 
struct NAMELISTADD_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct NAMELISTADD_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union NAMELISTADD_res switch (Return_Code rc) {
case RC_OK:
   NAMELISTADD_resok resok;
default:
   NAMELISTADD_resfail resfail;
};
 
/*
 * NAME_LIST_REMOVE definitions
 */
struct NAMELISTREM_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string Name<>;
};
 
struct NAMELISTREM_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct NAMELISTREM_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union NAMELISTREM_res switch (Return_Code rc) {
case RC_OK:
   NAMELISTREM_resok resok;
default:
   NAMELISTREM_resfail resfail;
};
 
/*
 * NAME_LIST_DESTROY definitions
 */
struct NAMELISTDES_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct NAMELISTDES_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct NAMELISTDES_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union NAMELISTDES_res switch (Return_Code rc) {
case RC_OK:
   NAMELISTDES_resok resok;
default:
   NAMELISTDES_resfail resfail;
};
 
/*
 * NAME_LIST_QUERY definitions
 */
struct NAMELISTQUERY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct Name_List_Query_Record {
   string Name<>;
   Name_List_Query_Record *next_entry;
};
 
struct NAMELISTQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   Name_List_Query_Record *name_entries;
};
 
struct NAMELISTQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union NAMELISTQUERY_res switch (Return_Code rc) {
case RC_OK:
   NAMELISTQUERY_resok resok;
default:
   NAMELISTQUERY_resfail resfail;
};
 
/*
 * STATIC_IMAGE_CHANGES_ACTIVATE definitions
 */
struct STATIMGCHGACT_args {
   Session_Token SessionToken;
};
 
struct STATIMGCHGACT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct STATIMGCHGACT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union STATIMGCHGACT_res switch (Return_Code rc) {
case RC_OK:
   STATIMGCHGACT_resok resok;
default:
   STATIMGCHGACT_resfail resfail;
};
 
/*
 * STATIC_IMAGE_CHANGES_DEACTIVATE definitions
 */
struct STATIMGCHGDEACT_args {
   Session_Token SessionToken;
};
 
struct STATIMGCHGDEACT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct STATIMGCHGDEACT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union STATIMGCHGDEACT_res switch (Return_Code rc) {
case RC_OK:
   STATIMGCHGDEACT_resok resok;
default:
   STATIMGCHGDEACT_resfail resfail;
};
 
/*
 * STATIC_IMAGE_CHANGES_IMMEDIATE definitions
 */
struct STATIMGCHGIMMED_args {
   Session_Token SessionToken;
};
 
struct STATIMGCHGIMMED_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct STATIMGCHGIMMED_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union STATIMGCHGIMMED_res switch (Return_Code rc) {
case RC_OK:
   STATIMGCHGIMMED_resok resok;
default:
   STATIMGCHGIMMED_resfail resfail;
};
 
/*
 * DIRECTORY_MANAGER_COMMAND definitions
 */
 
struct DIRMGRCMD_Input_Buffer {
   charNA Input_Record;
   DIRMGRCMD_Input_Buffer *next_entry;
};
 
struct DIRMGRCMD_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   charNA commandstring;
   DIRMGRCMD_Input_Buffer *inputbuffer;
};
 
struct DIRMGRCMD_Return_Buffer {
   charNA Output_Record;
   DIRMGRCMD_Return_Buffer *next_entry;
};
 
struct DIRMGRCMD_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   DIRMGRCMD_Return_Buffer *returnbuffer;
};
 
struct DIRMGRCMD_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
   DIRMGRCMD_Return_Buffer *returnbuffer;
};
 
union DIRMGRCMD_res switch (Return_Code rc) {
case RC_OK:
   DIRMGRCMD_resok resok;
default:
   DIRMGRCMD_resfail resfail;
};
 
/*
 * QUERY_DIRECTORY_MANAGER_LEVEL Definitions
 */
 
struct QUERYDIRMGRLEVEL_args {
   Session_Token SessionToken;
};
 
struct QUERYDIRMGRLEVEL_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   charNA Query_Record;
   unsigned int Min_Supported_Interface_Level;
   unsigned int Max_Supported_Interface_Level;
};
 
struct QUERYDIRMGRLEVEL_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union QUERYDIRMGRLEVEL_res switch (Return_Code rc) {
case RC_OK:
   QUERYDIRMGRLEVEL_resok resok;
default:
   QUERYDIRMGRLEVEL_resfail resfail;
};
 
/*
 * PROTOTYPE_NAME_QUERY Definitions
 */
 
struct PROTONAMEQUERY_args {
   Session_Token SessionToken;
};
 
struct PROTONAMEQUERY_Return_Buffer {
   string Prototype_Name<>;
   PROTONAMEQUERY_Return_Buffer *next_entry;
};
 
struct PROTONAMEQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   PROTONAMEQUERY_Return_Buffer *returnbuffer;
};
 
struct PROTONAMEQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union PROTONAMEQUERY_res switch (Return_Code rc) {
case RC_OK:
   PROTONAMEQUERY_resok resok;
default:
   PROTONAMEQUERY_resfail resfail;
};
 
/*
 * PROTOTYPE_CREATE Definitions
 */
 
struct PROTOCREATE_Input_Buffer {
   charNA Prototype_Record;
   PROTOCREATE_Input_Buffer *next_entry;
};
 
struct PROTOCREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   PROTOCREATE_Input_Buffer *InputBuffer;
};
 
struct PROTOCREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct PROTOCREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union PROTOCREATE_res switch (Return_Code rc) {
case RC_OK:
   PROTOCREATE_resok resok;
default:
   PROTOCREATE_resfail resfail;
};
 
/*
 * PROTOTYPE_REPLACE Definitions
 */
 
struct PROTOREPLACE_Input_Buffer {
   charNA Prototype_Record;
   PROTOREPLACE_Input_Buffer *next_entry;
};
 
struct PROTOREPLACE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   PROTOREPLACE_Input_Buffer *InputBuffer;
};
 
struct PROTOREPLACE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct PROTOREPLACE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union PROTOREPLACE_res switch (Return_Code rc) {
case RC_OK:
   PROTOREPLACE_resok resok;
default:
   PROTOREPLACE_resfail resfail;
};
 
/*
 * PROTOTYPE_DELETE Definitions
 */
 
struct PROTODELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct PROTODELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct PROTODELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union PROTODELETE_res switch (Return_Code rc) {
case RC_OK:
   PROTODELETE_resok resok;
default:
   PROTODELETE_resfail resfail;
};
 
/*
 * PROTOTYPE_QUERY Definitions
 */
 
struct PROTOQUERY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct PROTOQUERY_Return_Buffer {
   charNA Prototype_Record;
   PROTOQUERY_Return_Buffer *next_entry;
};
 
struct PROTOQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   PROTOQUERY_Return_Buffer *returnbuffer;
};
 
struct PROTOQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union PROTOQUERY_res switch (Return_Code rc) {
case RC_OK:
   PROTOQUERY_resok resok;
default:
   PROTOQUERY_resfail resfail;
};
 
/*
 * IMAGE_NAME_QUERY Definitions
 */
 
struct IMAGENAMEQUERY_args {
   Session_Token SessionToken;
};
 
struct IMAGENAMEQUERY_Return_Buffer {
   string Image_Name<>;
   IMAGENAMEQUERY_Return_Buffer *next_entry;
};
 
struct IMAGENAMEQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   IMAGENAMEQUERY_Return_Buffer *returnbuffer;
};
 
struct IMAGENAMEQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGENAMEQUERY_res switch (Return_Code rc) {
case RC_OK:
   IMAGENAMEQUERY_resok resok;
default:
   IMAGENAMEQUERY_resfail resfail;
};
 
 
/*
 * IMAGE_CREATE Definitions
 */
 
struct IMAGECREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string Image_Prototype<>;
   string Initial_Password<>;
   string Initial_Account_Number<>;
};
 
struct IMAGECREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGECREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGECREATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGECREATE_resok resok;
default:
   IMAGECREATE_resfail resfail;
};
 
/*
 * IMAGE_REPLACE Definitions
 */
 
struct IMAGEREPLACE_Input_Buffer {
   charNA Image_Record;
   IMAGEREPLACE_Input_Buffer *next_entry;
};
 
struct IMAGEREPLACE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   IMAGEREPLACE_Input_Buffer *InputBuffer;
};
 
struct IMAGEREPLACE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEREPLACE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEREPLACE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEREPLACE_resok resok;
default:
   IMAGEREPLACE_resfail resfail;
};
 
/*
 * IMAGE_DELETE Definitions
 */
 
struct IMAGEDELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Data_Security_Erase_Values Data_Security_Erase;
};
 
struct IMAGEDELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDELETE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDELETE_resok resok;
default:
   IMAGEDELETE_resfail resfail;
};
 
/*
 * IMAGE_QUERY Definitions
 */
 
struct IMAGEQUERY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct IMAGEQUERY_Return_Buffer {
   charNA Image_Record;
   IMAGEQUERY_Return_Buffer *next_entry;
};
 
struct IMAGEQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   IMAGEQUERY_Return_Buffer *ReturnBuffer;
};
 
struct IMAGEQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEQUERY_res switch (Return_Code rc) {
case RC_OK:
   IMAGEQUERY_resok resok;
default:
   IMAGEQUERY_resfail resfail;
};
 
/*
 * IMAGE_PASSWORD_SET Definitions
 */
 
struct IMAGEPWSET_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   charNA Image_Password;
};
 
struct IMAGEPWSET_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEPWSET_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEPWSET_res switch (Return_Code rc) {
case RC_OK:
   IMAGEPWSET_resok resok;
default:
   IMAGEPWSET_resfail resfail;
};
 
/*
 * IMAGE_ACTIVATE Definitions
 */
 
struct IMAGEACTIVATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct IMAGEACTIVATE_Return_Buffer {
   int NumImagesActivated;
   int NumImagesNotActivated;
   Failing_Images_List *FailingImagesList;
};
 
struct IMAGEACTIVATE_resfail_buffer_buf {
   Session_Token SessionToken;
   IMAGEACTIVATE_Return_Buffer ReturnBuffer;
};
 
struct IMAGEACTIVATE_resfail_buffer_nobuf {
   Session_Token SessionToken;
};
 
union IMAGEACTIVATE_resfail_buffer switch (Reason_Code rs) {
case RS_NOT_ALL:
   IMAGEACTIVATE_resfail_buffer_buf resfail_buf;
default:
   IMAGEACTIVATE_resfail_buffer_nobuf resfail_nobuf;
};
 
struct IMAGEACTIVATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEACTIVATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEACTIVATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEACTIVATE_resok resok;
case RCERR_IMAGEOP:
   IMAGEACTIVATE_resfail_buffer resfailbuf;
default:
   IMAGEACTIVATE_resfail resfail;
};
 
/*
 * IMAGE_DEACTIVATE Definitions
 */
 
struct IMAGEDEACTIVATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string ForceTime<>;                                     /*@SM049P2*/
};
 
struct IMAGEDEACTIVATE_Return_Buffer {
   int NumImagesDeactivated;
   int NumImagesNotDeactivated;
   Failing_Images_List *FailingImagesList;
};
 
struct IMAGEDEACTIVATE_resfail_buffer_buf {
   Session_Token SessionToken;
   IMAGEDEACTIVATE_Return_Buffer ReturnBuffer;
};
 
struct IMAGEDEACTIVATE_resfail_buffer_nobuf {
   Session_Token SessionToken;
};
 
union IMAGEDEACTIVATE_resfail_buffer switch (Reason_Code rs) {
case RS_SOME_NOT_DEACT:
   IMAGEDEACTIVATE_resfail_buffer_buf resfail_buf;
default:
   IMAGEDEACTIVATE_resfail_buffer_nobuf resfail_nobuf;
};
 
struct IMAGEDEACTIVATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDEACTIVATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDEACTIVATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDEACTIVATE_resok resok;
case RCERR_IMAGEOP:
   IMAGEDEACTIVATE_resfail_buffer resfailbuf;
default:
   IMAGEDEACTIVATE_resfail resfail;
};
 
/*
 * IMAGE_RECYCLE Definitions
 */
 
struct IMAGERECYCLE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
};
 
struct IMAGERECYCLE_Return_Buffer {
   int NumImagesRecycled;
   int NumImagesNotRecycled;
   Failing_Images_List *FailingImagesList;
};
 
struct IMAGERECYCLE_resfail_buffer_buf {
   Session_Token SessionToken;
   IMAGERECYCLE_Return_Buffer ReturnBuffer;
};
 
struct IMAGERECYCLE_resfail_buffer_nobuf {
   Session_Token SessionToken;
};
 
union IMAGERECYCLE_resfail_buffer switch (Reason_Code rs) {
case RS_SOME_NOT_RECYC:
   IMAGERECYCLE_resfail_buffer_buf resfail_buf;
default:
   IMAGERECYCLE_resfail_buffer_nobuf resfail_nobuf;
};
 
struct IMAGERECYCLE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGERECYCLE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGERECYCLE_res switch (Return_Code rc) {
case RC_OK:
   IMAGERECYCLE_resok resok;
case RCERR_IMAGEOP:
   IMAGERECYCLE_resfail_buffer resfailbuf;
default:
   IMAGERECYCLE_resfail resfail;
};
 
/*
 * IMAGE_DEVICE_RESET Definitions
 */
 
struct IMAGEDEVRESET_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string ImageDeviceNumber<>;
};
 
struct IMAGEDEVRESET_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDEVRESET_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDEVRESET_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDEVRESET_resok resok;
default:
   IMAGEDEVRESET_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_LAN_QUERY Definitions
 */
 
struct VIRTNETLANQUERY_args {
   Session_Token SessionToken;
   string Lan_Name<>;
   string Lan_Owner<>;
   string Lan_Type<>;
};
 
struct VIRTNETLANQUERY_Return_Buffer {
   charNA Output_Record;
   VIRTNETLANQUERY_Return_Buffer *next_entry;
};
 
struct VIRTNETLANQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   VIRTNETLANQUERY_Return_Buffer *ReturnBuffer;
};
 
struct VIRTNETLANQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETLANQUERY_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETLANQUERY_resok resok;
default:
   VIRTNETLANQUERY_resfail resfail;
};
 
/*
 * IMAGE_DISK_CREATE Definitions
 */
 
struct IMAGEDISKCREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDiskNumber<>;
   string ImageDiskDeviceType<>;
   string ImageDiskAllocationType<>;
   string AllocationAreaName<>;
   string AllocationUnitSize<>;
   int    ImageDiskSize;
   string ImageDiskmode<>;
   string ImageDiskFormatting<>;
   string ImageDiskLabel<>;
   string ReadPassword<>;
   string WritePassword<>;
   string MultiPassword<>;
};
 
struct IMAGEDISKCREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDISKCREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDISKCREATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDISKCREATE_resok resok;
default:
   IMAGEDISKCREATE_resfail resfail;
};
 
/*
 * IMAGE_DISK_COPY Definitions
 */
 
struct IMAGEDISKCOPY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDiskNumber<>;
   string SourceImageName<>;
   string SourceImageDiskNumber<>;
   string ImageDiskAllocationType<>;
   string AllocationAreaName<>;
   string Mode<>;
   string ReadPassword<>;
   string WritePassword<>;
   string MultiPassword<>;
};
 
struct IMAGEDISKCOPY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDISKCOPY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDISKCOPY_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDISKCOPY_resok resok;
default:
   IMAGEDISKCOPY_resfail resfail;
};
 
/*
 * IMAGE_DISK_SHARE Definitions
 */
 
struct IMAGEDISKSHARE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDiskNumber<>;
   string TargetImageName<>;
   string TargetImageDiskNumber<>;
   string ReadWriteMode<>;
   string OptionalPassword<>;
};
 
struct IMAGEDISKSHARE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDISKSHARE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDISKSHARE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDISKSHARE_resok resok;
default:
   IMAGEDISKSHARE_resfail resfail;
};
 
/*
 * IMAGE_DISK_DELETE Definitions
 */
 
struct IMAGEDISKDELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string Image_Disk_Number<>;
   Data_Security_Erase_Values Data_Security_Erase;
};
 
struct IMAGEDISKDELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDISKDELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDISKDELETE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDISKDELETE_resok resok;
default:
   IMAGEDISKDELETE_resfail resfail;
};
 
/*
 * IMAGE_DISK_UNSHARE Definitions
 */
 
struct IMAGEDISKUNSHARE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDiskNumber<>;
   string TargetImageName<>;
   string TargetImageDiskNumber<>;
};
 
struct IMAGEDISKUNSHARE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDISKUNSHARE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDISKUNSHARE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDISKUNSHARE_resok resok;
default:
   IMAGEDISKUNSHARE_resfail resfail;
};
 
/*
 * IMAGE_DEVICE_DEDICATE Definitions
 */
 
struct IMAGEDEVICEDEDICATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string RealDeviceNumber<>;
   string Readonly<>;
};
 
struct IMAGEDEVICEDEDICATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDEVICEDEDICATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDEVICEDEDICATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDEVICEDEDICATE_resok resok;
default:
   IMAGEDEVICEDEDICATE_resfail resfail;
};
 
/*
 * IMAGE_DEVICE_UNDEDICATE Definitions
 */
 
struct IMAGEDEVICEUNDEDICATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
};
 
struct IMAGEDEVICEUNDEDICATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEDEVICEUNDEDICATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEDEVICEUNDEDICATE_res switch (Return_Code rc) {
case RC_OK:
   IMAGEDEVICEUNDEDICATE_resok resok;
default:
   IMAGEDEVICEUNDEDICATE_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_CONNECTION_CREATE Definitions
 */
 
struct VIRTNETCONNCREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string CoupledImageName<>;
   string CoupledImageDeviceNumber<>;
};
 
struct VIRTNETCONNCREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETCONNCREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETCONNCREATE_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETCONNCREATE_resok resok;
default:
   VIRTNETCONNCREATE_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_CONNECTION_DELETE Definitions
 */
 
struct VIRTNETCONNDELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
};
 
struct VIRTNETCONNDELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETCONNDELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETCONNDELETE_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETCONNDELETE_resok resok;
default:
   VIRTNETCONNDELETE_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_ADAPTER_CREATE Definitions
 */
 
struct VIRTNETADAPTCREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string AdapterType<>;
   string NetworkAdapterDevices<>;
};
 
struct VIRTNETADAPTCREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETADAPTCREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETADAPTCREATE_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETADAPTCREATE_resok resok;
default:
   VIRTNETADAPTCREATE_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_ADAPTER_DELETE Definitions
 */
 
struct VIRTNETADAPTDELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
};
 
struct VIRTNETADAPTDELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETADAPTDELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETADAPTDELETE_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETADAPTDELETE_resok resok;
default:
   VIRTNETADAPTDELETE_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_LAN_CONNECT Definitions
 */
 
struct VIRTNETLANCONNECT_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string Lan_Name<>;
   string Lan_Owner<>;
   string Lan_Type<>;
   string NetworkAdapterDevices<>;
};
 
struct VIRTNETLANCONNECT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETLANCONNECT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETLANCONNECT_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETLANCONNECT_resok resok;
default:
   VIRTNETLANCONNECT_resfail resfail;
};
 
/*
 * VIRTUAL_NETWORK_LAN_DISCONNECT Definitions
 */
 
struct VIRTNETLANDISCONNECT_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string Lan_Name<>;
   string Lan_Owner<>;
   string Lan_Type<>;
};
 
struct VIRTNETLANDISCONNECT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETLANDISCONNECT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETLANDISCONNECT_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETLANDISCONNECT_resok resok;
default:
   VIRTNETLANDISCONNECT_resfail resfail;
};
 
/*************************************************
 *   VSMSERVE_Shutdown Definitions
 **************************************************/
 
struct VSMSERVESHUTDOWN_args {
   Session_Token SessionToken;
};
 
struct VSMSERVESHUTDOWN_resok {
   Reason_Code rs;
};
 
struct VSMSERVESHUTDOWN_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VSMSERVESHUTDOWN_res switch (Return_Code rc) {
case RC_OK:
   VSMSERVESHUTDOWN_resok resok;
default:
   VSMSERVESHUTDOWN_resfail resfail;
};
 
/*************************************************
 *   Virtual_Network_Vswitch_Connect Definitions
 **************************************************/
 
struct VIRTNETVSWCONNECT_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string SwitchName<>;
   string PortName<>;
   string RealDeviceAddress<>;
   string ConnectionValue<>;
   unsigned int QueueStorageLimit;
   string ControllerName<>;
   string NetworkAdapterDevices<>;
   string ChannelPathID<>;
   string MacId<>;
   string RoutingValue<>;                                 /*@SM635P2*/
};
 
struct VIRTNETVSWCONNECT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETVSWCONNECT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETVSWCONNECT_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETVSWCONNECT_resok resok;
default:
   VIRTNETVSWCONNECT_resfail resfail;
};
 
/*************************************************
 *   Virtual_Network_Vswitch_Set Definitions
 **************************************************/
 
struct VIRTNETVSWSET_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string SwitchName<>;
   string GrantUserid<>;
   string VLANID<>;
/* unsigned int VLANIDNumList;                              @SM392P2*/
   string RevokeUserid<>;
   string PortName<>;
   string RealDeviceAddress<>;
   string ConnectionValue<>;
   unsigned int QueueStorageLimit;
   string ControllerName<>;
   string RoutingValue<>;                                 /*@SM635P2*/
};
 
struct VIRTNETVSWSET_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETVSWSET_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETVSWSET_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETVSWSET_resok resok;
default:
   VIRTNETVSWSET_resfail resfail;
};
 
/*************************************************
 *   Virtual_Network_Vswitch_Disconnect Definitions
 **************************************************/
 
struct VIRTNETVSWDISCONNECT_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   Image_Instance ImageInstance;
   string ImageDeviceNumber<>;
   string SwitchName<>;
};
 
struct VIRTNETVSWDISCONNECT_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct VIRTNETVSWDISCONNECT_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETVSWDISCONNECT_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETVSWDISCONNECT_resok resok;
default:
   VIRTNETVSWDISCONNECT_resfail resfail;
};
 
/*************************************************
 *   Virtual_Network_Vswitch_Query Definitions
 **************************************************/
 
struct VIRTNETVSWQUERY_args {
   Session_Token SessionToken;
   string SwitchName<>;
   string VLANID<>;
};
 
struct VIRTNETVSWQUERY_Return_Buffer {
   charNA Vswitch_Record;
   VIRTNETVSWQUERY_Return_Buffer *next_entry;
};
 
struct VIRTNETVSWQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   VIRTNETVSWQUERY_Return_Buffer *ReturnBuffer;
};
 
struct VIRTNETVSWQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union VIRTNETVSWQUERY_res switch (Return_Code rc) {
case RC_OK:
   VIRTNETVSWQUERY_resok resok;
default:
   VIRTNETVSWQUERY_resfail resfail;
};
 
/*************************************************
 *   Shared_Storage_Create Definitions
 **************************************************/
 
struct SHAREDSTORAGECREATE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
   string PageRange<>;
   string PageAccessDescriptor<>;
   string StorageAttributes<>;
   string StorageAccessIdentifier<>;
};
 
struct SHAREDSTORAGECREATE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct SHAREDSTORAGECREATE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGECREATE_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGECREATE_resok resok;
default:
   SHAREDSTORAGECREATE_resfail resfail;
};
 
/*************************************************
 *   Shared_Storage_Replace Definitions
 **************************************************/
 
struct SHAREDSTORAGEREPLACE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
   string StorageAccessIdentifier<>;
};
 
struct SHAREDSTORAGEREPLACE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct SHAREDSTORAGEREPLACE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEREPLACE_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEREPLACE_resok resok;
default:
   SHAREDSTORAGEREPLACE_resfail resfail;
};
 
/*************************************************
 *   Shared_Storage_Delete Definitions
 **************************************************/
 
struct SHAREDSTORAGEDELETE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
};
 
struct SHAREDSTORAGEDELETE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct SHAREDSTORAGEDELETE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEDELETE_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEDELETE_resok resok;
default:
   SHAREDSTORAGEDELETE_resfail resfail;
};
 
/*************************************************
 *   Shared_Storage_Query Definitions
 **************************************************/
 
struct SHAREDSTORAGEQUERY_args {
   Session_Token SessionToken;
   string StorageSegmentName<>;
};
 
struct SHAREDSTORAGEQUERY_Return_Buffer {
   charNA Storage_Record;
   SHAREDSTORAGEQUERY_Return_Buffer *next_entry;
};
 
struct SHAREDSTORAGEQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   SHAREDSTORAGEQUERY_Return_Buffer *ReturnBuffer;
};
 
struct SHAREDSTORAGEQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEQUERY_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEQUERY_resok resok;
default:
   SHAREDSTORAGEQUERY_resfail resfail;
};
 
/**************************************************
 *   Shared_Storage_Access_Add
 **************************************************/
 
struct SHAREDSTORAGEACCESSADD_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
};
 
struct SHAREDSTORAGEACCESSADD_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct SHAREDSTORAGEACCESSADD_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEACCESSADD_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEACCESSADD_resok resok;
default:
   SHAREDSTORAGEACCESSADD_resfail resfail;
};
 
/**************************************************
 *   Shared_Storage_Access_Remove
 **************************************************/
 
struct SHAREDSTORAGEACCESSREMOVE_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
};
 
struct SHAREDSTORAGEACCESSREMOVE_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct SHAREDSTORAGEACCESSREMOVE_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEACCESSREMOVE_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEACCESSREMOVE_resok resok;
default:
   SHAREDSTORAGEACCESSREMOVE_resfail resfail;
};
 
/**************************************************
 *   Shared_Storage_Access_Query
 **************************************************/
 
struct SHAREDSTORAGEACCESSQUERY_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string StorageSegmentName<>;
};
 
struct SHAREDSTORAGEACCESSQUERY_Return_Buffer {
   string Userid<>;
   SHAREDSTORAGEACCESSQUERY_Return_Buffer *next_entry;
};
 
struct SHAREDSTORAGEACCESSQUERY_resok {
   Reason_Code rs;
   Session_Token SessionToken;
   SHAREDSTORAGEACCESSQUERY_Return_Buffer *ReturnBuffer;
};
 
struct SHAREDSTORAGEACCESSQUERY_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union SHAREDSTORAGEACCESSQUERY_res switch (Return_Code rc) {
case RC_OK:
   SHAREDSTORAGEACCESSQUERY_resok resok;
default:
   SHAREDSTORAGEACCESSQUERY_resfail resfail;
};
 
/*************************************************
 *   Image_Lock Definitions
 **************************************************/
 
struct IMAGELOCK_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string DeviceAddress<>;
};
 
struct IMAGELOCK_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGELOCK_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGELOCK_res switch (Return_Code rc) {
case RC_OK:
   IMAGELOCK_resok resok;
default:
   IMAGELOCK_resfail resfail;
};
 
/*************************************************
 *   Image_Unlock Definitions
 **************************************************/
 
struct IMAGEUNLOCK_args {
   Session_Token SessionToken;
   string TargetIdentifier<>;
   string DeviceAddress<>;
};
 
struct IMAGEUNLOCK_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct IMAGEUNLOCK_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union IMAGEUNLOCK_res switch (Return_Code rc) {
case RC_OK:
   IMAGEUNLOCK_resok resok;
default:
   IMAGEUNLOCK_resfail resfail;
};
 
/*************************************************
 *   Query_Asynchronus_Operation
 **************************************************/
 
struct QUERYASYNCOP_args {
   Session_Token SessionToken;
   unsigned int OperationID;
};
 
struct QUERYASYNCOP_resok {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
struct QUERYASYNCOP_resfail {
   Reason_Code rs;
   Session_Token SessionToken;
};
 
union QUERYASYNCOP_res switch (Return_Code rc) {
case RC_OK:
   QUERYASYNCOP_resok resok;
default:
   QUERYASYNCOP_resfail resfail;
};
 
/*
 * ------------------------- *
 * VSMAPI Program definition *
 * ------------------------- *
 */
 
program VSMAPI_PROGRAM {
    version VSMAPI_V1 {
 
    void VSMAPI_NULL(void) = 0;
 
    LOGIN_res
      LOGIN(LOGIN_args) = 1;
    LOGOUT_res
      LOGOUT(LOGOUT_args) = 2;
    MODSESSIONTIMEINTERVAL_res
      MODIFY_SESSION_TIMEOUT_INTERVAL(MODSESSIONTIMEINTERVAL_args) = 3;
    MODSERVERTIMEINTERVAL_res
      MODIFY_SERVER_TIMEOUT_INTERVAL(MODSERVERTIMEINTERVAL_args) = 4;
    QRYTIMEINTERVAL_res
      QUERY_TIMEOUT_INTERVAL(QRYTIMEINTERVAL_args) = 5;
    DEBUG_res
      VSMAPI_DEBUG(DEBUG_args) = 6;
    VSMSERVESHUTDOWN_res
      VSMSERVE_SHUTDOWN(VSMSERVESHUTDOWN_args) = 7;
 
    AUTHLISTADD_res
      AUTHORIZATION_LIST_ADD(AUTHLISTADD_args) = 8;
    AUTHLISTREM_res
      AUTHORIZATION_LIST_REMOVE(AUTHLISTREM_args) = 9;
    AUTHLISTQUERY_res
      AUTHORIZATION_LIST_QUERY(AUTHLISTQUERY_args) = 10;
 
    NAMELISTADD_res
      NAME_LIST_ADD(NAMELISTADD_args) = 11;
    NAMELISTREM_res
      NAME_LIST_REMOVE(NAMELISTREM_args) = 12;
    NAMELISTDES_res
      NAME_LIST_DESTROY(NAMELISTDES_args) = 13;
    NAMELISTQUERY_res
      NAME_LIST_QUERY(NAMELISTQUERY_args) = 14;
 
    STATIMGCHGACT_res
      STATIC_IMAGE_CHANGES_ACTIVATE(STATIMGCHGACT_args) = 15;
    STATIMGCHGDEACT_res
      STATIC_IMAGE_CHANGES_DEACTIVATE(STATIMGCHGDEACT_args) = 16;
    STATIMGCHGIMMED_res
      STATIC_IMAGE_CHANGES_IMMEDIATE(STATIMGCHGIMMED_args) = 17;
    DIRMGRCMD_res
      DIRECTORY_MANAGER_COMMAND(DIRMGRCMD_args) = 18;
    QUERYDIRMGRLEVEL_res
      QUERY_DIRECTORY_MANAGER_LEVEL(QUERYDIRMGRLEVEL_args) = 19;
    QUERYASYNCOP_res
      QUERY_ASYNCHRONOUS_OPERATION(QUERYASYNCOP_args) = 20;
 
    PROTONAMEQUERY_res
      PROTOTYPE_NAME_QUERY(PROTONAMEQUERY_args) = 21;
    PROTOCREATE_res
      PROTOTYPE_CREATE(PROTOCREATE_args) = 22;
    PROTOREPLACE_res
      PROTOTYPE_REPLACE(PROTOREPLACE_args) = 23;
    PROTODELETE_res
      PROTOTYPE_DELETE(PROTODELETE_args) = 24;
    PROTOQUERY_res
      PROTOTYPE_QUERY(PROTOQUERY_args) = 25;
 
    IMAGENAMEQUERY_res
      IMAGE_NAME_QUERY(IMAGENAMEQUERY_args) = 26;
    IMAGECREATE_res
      IMAGE_CREATE(IMAGECREATE_args) = 27;
    IMAGEREPLACE_res
      IMAGE_REPLACE(IMAGEREPLACE_args) = 28;
    IMAGEDELETE_res
      IMAGE_DELETE(IMAGEDELETE_args) = 29;
    IMAGEQUERY_res
      IMAGE_QUERY(IMAGEQUERY_args) = 30;
    IMAGEPWSET_res
      IMAGE_PASSWORD_SET(IMAGEPWSET_args) = 31;
    IMAGELOCK_res
      IMAGE_LOCK(IMAGELOCK_args) = 32;                   /*@SM083P2*/
    IMAGEUNLOCK_res
      IMAGE_UNLOCK(IMAGEUNLOCK_args) = 33;               /*@SM083P2*/
 
    IMAGEACTIVATE_res
      IMAGE_ACTIVATE(IMAGEACTIVATE_args) = 34;
    IMAGEDEACTIVATE_res
      IMAGE_DEACTIVATE(IMAGEDEACTIVATE_args) = 35;
    IMAGERECYCLE_res
      IMAGE_RECYCLE(IMAGERECYCLE_args) = 36;
    IMAGEDEVRESET_res
      IMAGE_DEVICE_RESET(IMAGEDEVRESET_args) = 37;
    VIRTNETLANQUERY_res
      VIRTUAL_NETWORK_LAN_QUERY(VIRTNETLANQUERY_args) = 38;
 
    IMAGEDISKCREATE_res
      IMAGE_DISK_CREATE(IMAGEDISKCREATE_args) = 39;
    IMAGEDISKCOPY_res
      IMAGE_DISK_COPY(IMAGEDISKCOPY_args) = 40;
    IMAGEDISKSHARE_res
      IMAGE_DISK_SHARE(IMAGEDISKSHARE_args) = 41;
    IMAGEDISKDELETE_res
      IMAGE_DISK_DELETE(IMAGEDISKDELETE_args) = 42;
    IMAGEDISKUNSHARE_res
      IMAGE_DISK_UNSHARE(IMAGEDISKUNSHARE_args) = 43;
    IMAGEDEVICEDEDICATE_res
      IMAGE_DEVICE_DEDICATE(IMAGEDEVICEDEDICATE_args) = 44;
    IMAGEDEVICEUNDEDICATE_res
      IMAGE_DEVICE_UNDEDICATE(IMAGEDEVICEUNDEDICATE_args) = 45;
 
    VIRTNETCONNCREATE_res
      VIRTUAL_NETWORK_CONNECTION_CREATE(VIRTNETCONNCREATE_args) = 46;
    VIRTNETCONNDELETE_res
      VIRTUAL_NETWORK_CONNECTION_DELETE(VIRTNETCONNDELETE_args) = 47;
    VIRTNETADAPTCREATE_res
      VIRTUAL_NETWORK_ADAPTER_CREATE(VIRTNETADAPTCREATE_args) = 48;
    VIRTNETADAPTDELETE_res
      VIRTUAL_NETWORK_ADAPTER_DELETE(VIRTNETADAPTDELETE_args) = 49;
    VIRTNETLANCONNECT_res
      VIRTUAL_NETWORK_LAN_CONNECT(VIRTNETLANCONNECT_args) = 50;
    VIRTNETLANDISCONNECT_res
      VIRTUAL_NETWORK_LAN_DISCONNECT(VIRTNETLANDISCONNECT_args) = 51;
 
    VIRTNETVSWCONNECT_res
      VIRTUAL_NETWORK_VSWITCH_CONNECT(VIRTNETVSWCONNECT_args) = 52;
    VIRTNETVSWSET_res
      VIRTUAL_NETWORK_VSWITCH_SET(VIRTNETVSWSET_args) = 53;
    VIRTNETVSWDISCONNECT_res
      VIRTUAL_NETWORK_VSWITCH_DISCONNECT(VIRTNETVSWDISCONNECT_args)=54;
    VIRTNETVSWQUERY_res
      VIRTUAL_NETWORK_VSWITCH_QUERY(VIRTNETVSWQUERY_args) = 55;
 
    SHAREDSTORAGECREATE_res
      SHARED_STORAGE_CREATE(SHAREDSTORAGECREATE_args) = 56;
    SHAREDSTORAGEREPLACE_res
      SHARED_STORAGE_REPLACE(SHAREDSTORAGEREPLACE_args) = 57;
    SHAREDSTORAGEDELETE_res
      SHARED_STORAGE_DELETE(SHAREDSTORAGEDELETE_args) = 58;
    SHAREDSTORAGEQUERY_res
      SHARED_STORAGE_QUERY(SHAREDSTORAGEQUERY_args) = 59;
    SHAREDSTORAGEACCESSADD_res
      SHARED_STORAGE_ACCESS_ADD(SHAREDSTORAGEACCESSADD_args)=60;
      /*@SM083P2*/
    SHAREDSTORAGEACCESSREMOVE_res
      SHARED_STORAGE_ACCESS_REMOVE(SHAREDSTORAGEACCESSREMOVE_args)=61;
      /*@SM083P2*/
    SHAREDSTORAGEACCESSQUERY_res
      SHARED_STORAGE_ACCESS_QUERY(SHAREDSTORAGEACCESSQUERY_args)=62;
      /*@SM083P2*/
 
    } = 1;
} = 300762;
 
#ifdef __VM__
#ifdef RPC_XDR
%/* For VM, the charNA type cannot be opaque.  Instead, we */
%/* define the charNA type to be what RPCGEN gives us.     */
%/* Now we define the xdr_charNA() routine to be the same  */
%/* as what RPCGEN would give us, plus the translation to  */
%/* and from ascii to ebcdic and visa versa.               */
%
%/* The externs are defined in VMRPC TXTLIB */
%extern char asciitoebcdic[];        /* If tables not loaded  */
%extern char ebcdictoascii[];        /* If tables not loaded  */
%#pragma linkage(CMXLATE, OS)
%extern CMXLATE();                   /* Translation routine   */
%
%extern char rpcAToE[256];           /* Ascii to Ebcdic table */
%extern char rpcEToA[256];           /* Ebcdic to Ascii table */
%extern int  tablesLoaded;           /* Initially not loaded  */
%
%bool_t
%xdr_charNA(xdrs, objp)
%    XDR *xdrs;
%    charNA *objp;
%{
%
%    /* If translate tables are not loaded..load them now */
%    if (tablesLoaded == 0) {
%       loadRPCTranslateTables();
%    }
%
%    /* If we are encoding, encode the data now */
%    if (xdrs->x_op == XDR_ENCODE) {
%       if (tablesLoaded) { /* Use what we loaded */
%          CMXLATE(objp->charNA_val,
%                  rpcEToA,
%                  objp->charNA_len);
%       }
%       else { /* Use the one linked with us */
%          CMXLATE(objp->charNA_val,
%                  ebcdictoascii,
%                  objp->charNA_len);
%       }
%    }
%
%    /* Now do what the rpcgen'ed xdr_charNA does */
%    if (!xdr_bytes(xdrs,
%                   (char **)&objp->charNA_val,
%                   (u_int *)&objp->charNA_len, ~0)) {
%         return (FALSE);
%    }
%
%    /* If we are decoding, decode the data now */
%    if (xdrs->x_op == XDR_DECODE) {
%       if (tablesLoaded) { /* Use what we loaded */
%          CMXLATE(objp->charNA_val,
%                  rpcAToE,
%                  objp->charNA_len);
%       }
%       else { /* Use the one linked with us */
%          CMXLATE(objp->charNA_val,
%                  asciitoebcdic,
%                  objp->charNA_len);
%       }
%    }
%
%    return (TRUE);
%}
#endif /* RPC_XDR */
#endif /* __VM__ */
openSUSE Build Service is sponsored by