deon
/
tsmpipe
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2024-04-08. You can view files and clone it, but cannot push or open issues or pull requests.
tsmpipe/lib/dsmsession.c

584 lines
16 KiB
C
Raw Blame History

/*
* This function will set up a session to the TSM server and return the
* session handler
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <termio.h>
#include <unistd.h>
#include "dsmrc.h"
#include "dsmapitd.h"
#include "dsmapifp.h"
#include "../tsmpipe.h"
dsBool_t compressEnabled=bFalse; // Is compression enabled
/* Print out TSM Error Code */
char *tsm_printerr(dsUint32_t dsmHandle, dsInt16_t rc) {
char rcStr[DSM_MAX_RC_MSG_LENGTH];
char *s;
s = malloc(DSM_MAX_RC_MSG_LENGTH+5);
if (rc == DSM_RC_WILL_ABORT) {
dsUint16_t reason;
rc = dsmEndTxn(dsmHandle, DSM_VOTE_COMMIT, &reason);
if (rc == DSM_RC_CHECK_REASON_CODE)
rc = reason;
}
dsmRCMsg(dsmHandle,rc,rcStr);
strtok(rcStr, "\n");
sprintf(s,"[rc=%s]",rcStr);
return s;
}
/* Check the TSM API Version */
int tsm_checkapi(void) {
dsmApiVersionEx apiLibVer;
dsUint32_t apiVersion;
dsUint32_t applVersion = (10000 * DSM_API_VERSION) + (1000 * DSM_API_RELEASE) + (100 * DSM_API_LEVEL) + DSM_API_SUBLEVEL;
memset(&apiLibVer,0x00,sizeof(dsmApiVersionEx));
apiLibVer.stVersion = apiVersionExVer;
dsmQueryApiVersionEx(&apiLibVer);
apiVersion = (10000 * apiLibVer.version) + (1000 * apiLibVer.release) + (100 * apiLibVer.level) + apiLibVer.subLevel;
if (apiVersion < applVersion) {
printf("The Tivoli Storage Manager API library Version (%d.%d.%d.%d) is at a lower version than the application version (%d.%d.%d.%d)\n",
apiLibVer.version,
apiLibVer.release,
apiLibVer.level,
apiLibVer.subLevel,
DSM_API_VERSION,
DSM_API_RELEASE,
DSM_API_LEVEL,
DSM_API_SUBLEVEL);
printf("Please upgrade the API accordingly.\n");
return 0;
}
return 1;
}
/* Initialise a session to the TSM server */
dsUint32_t tsm_initsess(char *options, char *password) {
dsInt16_t rc=0;
dsUint32_t dsmHandle=0;
dsmApiVersionEx applApi;
dsmAppVersion pipeApi;
dsmInitExIn_t initIn;
dsmInitExOut_t initOut;
optStruct dsmOpt;
ApiSessInfo dsmSessInfo;
if (! tsm_checkapi()) {
exit(2);
}
memset(&applApi,0x00,sizeof(dsmApiVersionEx));
applApi.stVersion = apiVersionExVer;
applApi.version = DSM_API_VERSION;
applApi.release = DSM_API_RELEASE;
applApi.level = DSM_API_LEVEL;
applApi.subLevel = DSM_API_SUBLEVEL;
memset(&pipeApi,0x00,sizeof(dsmAppVersion));
pipeApi.stVersion = appVersionVer;
pipeApi.applicationVersion = TSMPIPE_VERSION;
pipeApi.applicationRelease = TSMPIPE_RELEASE;
pipeApi.applicationLevel = TSMPIPE_LEVEL;
pipeApi.applicationSubLevel = TSMPIPE_SUBLEVEL;
memset(&initIn,0x00,sizeof(dsmInitExIn_t));
initIn.stVersion = dsmInitExInVersion;
initIn.apiVersionExP = &applApi;
initIn.clientNodeNameP = NULL;
initIn.clientOwnerNameP = NULL;
initIn.clientPasswordP = password;
initIn.applicationTypeP = NULL;
initIn.configfile = NULL;
initIn.options = options;
initIn.userNameP = NULL;
initIn.userPasswordP = NULL;
initIn.appVersionP = &pipeApi;
//initIn.dirDelimiter = dirDelimiter;
//initIn.useUnicode = useUnicode;
//initIn.bEncryptKeyEnabled = encrypt;
//initIn.encryptionPasswordP = encryptKey;
memset(&initOut,0x00,sizeof(dsmInitExOut_t));
initOut.stVersion = dsmInitExOutVersion;
rc = dsmInitEx(&dsmHandle, &initIn, &initOut);
/* If the TSM password has expired, change it. */
if (rc == DSM_RC_REJECT_VERIFIER_EXPIRED) {
rc = dsmChangePW(dsmHandle,NULL,NULL);
if (rc != DSM_RC_OK) {
printf("%s: dsmChangePW() failed %s\n",__func__,tsm_printerr(dsmHandle,rc));
dsmTerminate(dsmHandle);
return 0;
}
} else if (rc != DSM_RC_OK) {
printf("%s: dsmInitEx() failed %s\n",__func__,tsm_printerr(dsmHandle, rc));
dsmTerminate(dsmHandle);
return 0;
}
// Make sure if we have compression enabled, that we also have COMPRESSAlways YES
memset(&dsmOpt,0x00,sizeof(dsmOpt));
rc = dsmQuerySessOptions(dsmHandle, &dsmOpt);
memset(&dsmSessInfo,0x00,sizeof(ApiSessInfo));
dsmSessInfo.stVersion = ApiSessInfoVersion; /* Init struct version */
rc = dsmQuerySessInfo(dsmHandle, &dsmSessInfo);
rc = 1;
switch (dsmSessInfo.compression) {
case COMPRESS_YES : compressEnabled = bTrue; break;
case COMPRESS_NO : compressEnabled = bFalse; break;
case COMPRESS_CD : compressEnabled = dsmOpt.compression; break;
default: rc=0;
}
if (!rc || (compressEnabled && ! dsmOpt.compressalways)) {
debugLog(0,__func__,!rc ? "ERROR: Error Querying Session Capabilities" : "ERROR: COMPRESSion is ENABLED, but not COMPRESSAlways Yes",1);
}
return dsmHandle;
}
/* List objects that are in TSM */
int tsm_sessioninfo(dsUint32_t dsmHandle) {
extern int verbose;
dsInt16_t rc=0;
optStruct dsmOpt;
ApiSessInfo dsmSessInfo;
dsmApiVersionEx apiLibVer;
char t[50];
memset(&apiLibVer,0x00,sizeof(dsmApiVersionEx));
apiLibVer.stVersion = apiVersionExVer;
dsmQueryApiVersionEx(&apiLibVer);
printf("Application Version:\n");
printf(" TSMPIPE Version: %d.%d.%d.%d\n",
TSMPIPE_VERSION,
TSMPIPE_RELEASE,
TSMPIPE_LEVEL,
TSMPIPE_SUBLEVEL);
printf(" TSMPIPE API Version: %d.%d.%d.%d\n",
DSM_API_VERSION,
DSM_API_RELEASE,
DSM_API_LEVEL,
DSM_API_SUBLEVEL);
printf(" TSM Library: %d.%d.%d.%d\n",
apiLibVer.version,
apiLibVer.release,
apiLibVer.level,
apiLibVer.subLevel);
printf("\n");
memset(&dsmOpt,0x00,sizeof(dsmOpt));
rc = dsmQuerySessOptions(dsmHandle, &dsmOpt);
if (rc)
printf("%s: ERROR dsmQuerySessOptions() unable to query Session Options. RC = %d\n",__func__,rc);
else {
printf("dsmQuerySessOptions:\n");
printf(" DSMI_DIR: %s\n",dsmOpt.dsmiDir);
printf(" DSMI_CONFIG: %s\n",dsmOpt.dsmiConfig);
printf(" SErvername: %s\n",dsmOpt.serverName);
switch (dsmOpt.commMethod) {
case DSM_COMM_TCP : strcpy(t,"TCP/IP"); break;
case DSM_COMM_NAMEDPIPE : strcpy(t,"NAMED PIPE"); break;
case DSM_COMM_SHM : strcpy(t,"SHARED MEMORY"); break;
case DSM_COMM_TCPIP6 : strcpy(t,"TCP/IP v6"); break;
default: strcpy(t,"UNKNOWN");
}
printf(" COMMmethod: %s\n",t);
if (verbose)
fprintf(stderr,"%s: commMethod: [%d]\n",__func__,dsmOpt.commMethod);
printf(" TCPServerAddress: %s\n",dsmOpt.serverAddress);
if (verbose)
fprintf(stderr,"%s: serverAddress: [%s]\n",__func__,dsmOpt.serverAddress);
printf(" NODEName: %s\n",dsmOpt.nodeName);
printf(" COMPRESSIon: %s\n",dsmOpt.compression ? "YES" : "NO");
printf(" COMPRESSAlways: %s\n",dsmOpt.compressalways ? "YES" : "NO");
printf(" PASSWORDAccess: %s\n",dsmOpt.passwordAccess ? "GENERATE" : "PROMPT");
}
memset(&dsmSessInfo,0x00,sizeof(ApiSessInfo));
dsmSessInfo.stVersion = ApiSessInfoVersion; /* Init struct version */
rc = dsmQuerySessInfo(dsmHandle, &dsmSessInfo);
if (rc)
printf("%s: ERROR dsmQuerySessInfo() unable to query Session Info. RC = %d\n",__func__,rc);
else {
printf("\n");
printf("dsmQuerySessInfo:\n");
printf(" Server Information:\n");
printf(" Name: %s\n",dsmSessInfo.adsmServerName);
printf(" Host: %s\n",dsmSessInfo.serverHost);
printf(" Port: %u\n",dsmSessInfo.serverPort);
printf(" Date: %s\n",dsmDateToStr(dsmSessInfo.serverDate));
printf(" Type: %s\n",dsmSessInfo.serverType);
printf(" Version: %i.%i.%i.%i\n",
dsmSessInfo.serverVer,
dsmSessInfo.serverRel,
dsmSessInfo.serverLev,
dsmSessInfo.serverSubLev);
printf(" Archive Retention Protection : %s\n",dsmSessInfo.archiveRetentionProtection ? "YES" : "NO");
printf("\n");
printf(" Client Information:\n");
printf(" Node: %s\n",dsmSessInfo.id);
printf(" Node Type: %s\n",dsmSessInfo.nodeType);
printf(" Filespace delimiter: %c\n",dsmSessInfo.fsdelim);
printf(" HL & LL delimiter: %c\n",dsmSessInfo.hldelim);
switch (dsmSessInfo.compression) {
case COMPRESS_YES : strcpy(t,"ON"); break;
case COMPRESS_NO : strcpy(t,"OFF"); break;
case COMPRESS_CD : strcpy(t,"CLIENT"); break;
default: strcpy(t,"UNKNOWN");
}
printf(" Client compression: %s\n",t);
switch (dsmSessInfo.archDel) {
case ARCHDEL_YES : strcpy(t,"YES"); break;
case ARCHDEL_NO : strcpy(t,"NO"); break;
default: strcpy(t,"UNKNOWN");
}
printf(" ARCHIVE Delete: %s\n",t);
switch (dsmSessInfo.backDel) {
case BACKDEL_YES : strcpy(t,"YES"); break;
case ARCHDEL_NO : strcpy(t,"NO"); break;
default: strcpy(t,"UNKNOWN");
}
printf(" BACKUP delete: %s\n",t);
printf(" MAX objects per transactions: %u\n", dsmSessInfo.maxObjPerTxn);
printf(" LAN FREE Enabled: %s\n",dsmSessInfo.lanFreeEnabled ? "YES" : "NO");
printf(" Deduplication: %s\n",dsmSessInfo.dedupType == dedupClientOrServer ? "Client Or Server" : "Server Only");
printf("\n");
printf(" General session info:\n");
printf(" Owner: %s\n",dsmSessInfo.owner);
printf(" API Config file: %s\n",dsmSessInfo.confFile);
printf("\n");
printf(" Policy Information:\n");
printf(" Domain name: %s\n",dsmSessInfo.domainName);
printf(" Policyset name: %s\n",dsmSessInfo.policySetName);
printf(" Policy activation date: %s\n",dsmDateToStr(dsmSessInfo.polActDate));
printf(" Default management class: %s\n",dsmSessInfo.dfltMCName);
printf(" BACKUP retention grace: %u days\n",dsmSessInfo.gpBackRetn);
printf(" ARCHIVE retention grace: %u days\n",dsmSessInfo.gpArchRetn);
printf("\n");
}
return 1;
}
/*
* Query TSM for a list of objects.
*
* We use a callback to process the list, the callback should return:
* -1 upon error condition, application should exit.
* 0 if tsm_queryfile() should skip processing the remaining matches.
* 1 otherwise.
*/
dsInt16_t tsm_queryfile(dsUint32_t dsmHandle, dsmQueryType qType, tsm_query_callback usercb, void *userdata, qryArchiveData qaData, qryBackupData qbData, dsBool_t friendly) {
extern int verbose;
dsInt16_t rc=0;
dsmQueryBuff *qDataP;
DataBlk qResp;
memset(&qResp,0x00,sizeof(DataBlk));
qResp.stVersion = DataBlkVersion;
switch (qType) {
case qtArchive:
qDataP = &qaData;
qryRespArchiveData qaResp;
qResp.bufferLen = sizeof(qaResp);
qResp.bufferPtr = (char *) &qaResp;
qaResp.stVersion = qryRespArchiveDataVersion;
if (verbose)
fprintf(stderr,"%s: Query filespace %s\n",__func__,dsmObjnameToStr(*qaData.objName));
break;
case qtBackup:
qDataP = &qbData;
qryRespBackupData qbResp;
qResp.bufferLen = sizeof(qbResp);
qResp.bufferPtr = (char *) &qbResp;
qbResp.stVersion = qryRespBackupDataVersion;
if (verbose)
fprintf(stderr,"%s: Query filespace %s\n",__func__,dsmObjnameToStr(*qbData.objName));
if (verbose > 1) {
fprintf(stderr,"%s: PIT Date: %s\n",__func__,dsmDateToStr(qbData.pitDate));
fprintf(stderr,"%s: OBJSTATE : %s\n",__func__,qbData.objState==DSM_ACTIVE ? "DSM_ACTIVE" : "DSM_ANY_MATCH");
}
break;
default:
fprintf(stderr,"%s: UNKNOWN Type %d\n",__func__,qType);
exit(1);
}
rc = dsmBeginQuery(dsmHandle, qType, qDataP);
if (rc != DSM_RC_OK) {
printf("%s: dsmBeginQuery() failed %s\n",__func__,tsm_printerr(dsmHandle,rc));
return rc;
}
/* Loop and apply our callback to the result */
while ((rc = dsmGetNextQObj(dsmHandle, &qResp)) == DSM_RC_MORE_DATA) {
int cbret;
if(verbose > 1) {
dsmObjName *rObjName;
if (qType == qtArchive) {
qryRespArchiveData *qr = (void *) qResp.bufferPtr;
rObjName = &(qr->objName);
} else if (qType == qtBackup) {
qryRespBackupData *qr = (void *) qResp.bufferPtr;
rObjName = &(qr->objName);
} else {
fprintf(stderr,"%s: UNKNOWN Type %d\n",__func__,qType);
return DSM_RC_UNKNOWN_ERROR;
}
fprintf(stderr,"%s: Match file %s\n",__func__,dsmObjnameToStr(*rObjName));
}
if (usercb == NULL)
continue;
cbret = usercb(qType,&qResp,userdata,friendly);
if (cbret < 0) {
return DSM_RC_UNKNOWN_ERROR;
} else if(cbret == 0) {
break;
}
}
if (rc != DSM_RC_FINISHED && rc != DSM_RC_MORE_DATA) {
printf("%s: dsmGetNextQObj() failed %s\n",__func__,tsm_printerr(dsmHandle,rc));
return rc;
}
rc = dsmEndQuery(dsmHandle);
if (rc != DSM_RC_OK) {
printf("%s: dsmEndQuery() failed %s\n",__func__,tsm_printerr(dsmHandle,rc));
return rc;
}
return DSM_RC_OK;
}
/* Signal handler */
int intrupt = 0;
void Catch(int signo) {
if(signo) {}; /* so compiler won't complain about unused arguments */
intrupt = 1;
}
/* Uses sigaction to establish signal handler */
int install_sig_handler(int signum, void (*sig_handler)(int)) {
struct sigaction action;
int rc;
action.sa_handler = sig_handler; /* signal handler function */
sigemptyset( &action.sa_mask ); /* mask of signals to block */
action.sa_flags = SA_NOCLDSTOP;
rc = sigaction(
signum, /* I */ /* signal identifier */
&action, /* *I */ /* new action for signal */
NULL ); /* *O */ /* previous action - not needed */
return (rc);
}
int ReadPass(char *text, char *buffer, int length) {
struct termio ttyState, ttyStateSave;
register char *p;
register int c;
int rc;
FILE *ttyFH;
struct sigaction action;
/* Let's flush any prompt to the terminal that may be pending. */
fflush(stdout);
/* Open the console input device */
if((ttyFH = fopen("/dev/tty", "r")) == NULL)
return(-1);
else
setbuf(ttyFH, (char *)NULL);
/* Reset the interrupt flag */
intrupt = 0;
/* Trap the "BREAK" interrupt */
(void) sigaction( SIGINT, NULL, &action ); /* save current hdlr */
(void) install_sig_handler( SIGINT, Catch ); /* install new hdlr */
/* Get current state */
rc = ioctl(fileno(ttyFH), TCGETA, &ttyStateSave);
if (rc == -1)
return(-1);
/* Copy the saved tty state into a work field */
ttyState = ttyStateSave;
/* Turn off ECHO */
ttyState.c_lflag &= ~ECHO;
rc = ioctl(fileno(ttyFH), TCSETA, &ttyState);
if (rc == -1)
return(-1);
printf(text);
/* Read the password (quietly) */
for(p=buffer; !intrupt && (c = getc(ttyFH)) != '\n' && c != EOF; ) {
if(p < buffer+length)
*p++ = c;
}
*p = '\0';
printf("\n");
/* Restore the tty state settings */
rc = ioctl(fileno(ttyFH), TCSETA, &ttyStateSave);
if (rc == -1)
return(-1);
/* Reset the interrupt handler */
(void) sigaction( SIGINT, &action, NULL );
if(ttyFH != stdin)
(void) fclose(ttyFH);
if(intrupt)
(void) kill(getpid(), SIGINT);
return(strlen(buffer));
}
/*
* Set the TSM Node password
*
* We use a callback to process the list, the callback should return:
*/
int tsm_setpassword(char *options) {
uint32 dsmHandle;
bool_t done = bFalse;
uint16 pw_trys = 0;
uint16 len = 0;
char input[INPUTLEN];
char pw_cur[DSM_MAX_VERIFIER_LENGTH + 1];
char pw_new [DSM_MAX_VERIFIER_LENGTH + 1];
int rc;
while (!done) {
// Current Password
rc = ReadPass("Enter your current password: ",input,INPUTLEN);
len = strlen(input);
if ((len > DSM_MAX_VERIFIER_LENGTH) || !len || (rc < 0)) {
printf("Current password is invalid. Please try again.\n");
continue;
} else {
strcpy(pw_cur,input);
}
// New password
rc = ReadPass("Enter your new password: ",input,INPUTLEN);
len = strlen(input);
if ((len > DSM_MAX_VERIFIER_LENGTH) || !len || (rc < 0)) {
printf("New password is invalid. Please try again.\n");
continue;
} else {
strcpy(pw_new,input);
}
// Verify new password
rc = ReadPass("Enter your new password again: ",input,INPUTLEN);
len = strlen(input);
if ((len > DSM_MAX_VERIFIER_LENGTH) || !len || (rc < 0)) {
printf("New password is invalid. Please try again.\n");
continue;
} else {
// Compare new pw copies to make sure no typos from user.
if ((strcmp(pw_new,input))) {
pw_trys++;
if (pw_trys > 3)
debugLog(0,__func__,"ERROR: Passwords dont match, tried too many times.",3);
else
debugLog(0,__func__,"WARN: Your new passwords do not match, please try again...",0);
} else {
done = bTrue;
}
}
}
dsmHandle = tsm_initsess(options,pw_cur);
if (! dsmHandle) {
debugLog(0,__func__,"ERROR: Unable to create TSM session with your password.",2);
}
rc = dsmChangePW(dsmHandle,pw_cur,pw_new);
if (rc)
debugLog(0,__func__,"ERROR: Password change failed.",2);
else
printf("\nYour new password has been accepted and updated.\n");
dsmTerminate(dsmHandle);
return 1;
}
Reference in New Issue View Git Blame Copy Permalink