reindent-20030715
[openafs.git] / src / butc / butc_xbsa.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  * 
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 #ifdef xbsa
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15 RCSID
16     ("$Header$");
17
18 #include <sys/types.h>
19 #include <afs/stds.h>
20 #include <stdio.h>
21 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV)
22 #include <dlfcn.h>
23 #endif
24 #include <errno.h>
25 #include "butc_xbsa.h"
26 #include <afs/butx.h>
27
28 extern int debugLevel;
29
30
31 char resourceType[20] = "LFS FILE SYSTEM";
32 #define GOODSTR(s) ((s)?(s):"<NULL>")
33
34 BSA_Int16(*XBSAInit) (BSA_UInt32 *, SecurityToken *, ObjectOwner *, char **);
35 BSA_Int16(*XBSABeginTxn) (BSA_UInt32);
36 BSA_Int16(*XBSAEndTxn) (BSA_UInt32, Vote);
37 BSA_Int16(*XBSATerminate) (BSA_UInt32);
38 BSA_Int16(*XBSAQueryObject) (BSA_UInt32, QueryDescriptor *,
39                              ObjectDescriptor *);
40 BSA_Int16(*XBSAGetObject) (BSA_UInt32, ObjectDescriptor *, DataBlock *);
41 BSA_Int16(*XBSAEndData) (BSA_UInt32);
42 BSA_Int16(*XBSACreateObject) (BSA_UInt32, ObjectDescriptor *, DataBlock *);
43 BSA_Int16(*XBSADeleteObject) (BSA_UInt32, CopyType, ObjectName *, CopyId *);
44 BSA_Int16(*XBSAMarkObjectInactive) (BSA_UInt32, ObjectName *);
45 BSA_Int16(*XBSASendData) (BSA_UInt32, DataBlock *);
46 BSA_Int16(*XBSAGetData) (BSA_UInt32, DataBlock *);
47 BSA_Int16(*XBSAQueryApiVersion) (ApiVersion *);
48 BSA_Int16(*XBSAGetEnvironment) (BSA_UInt32, ObjectOwner *, char **);
49
50
51 xbsa_error(int rc, struct butx_transactionInfo *info)
52 {
53     switch (rc) {
54     case BSA_RC_AUTHENTICATION_FAILURE:
55         ELog(0, "     XBSA: Authentication failure\n");
56         break;
57     case BSA_RC_INVALID_KEYWORD:
58         ELog(0, "     XBSA: A specified keyword is invalid\n");
59         break;
60     case BSA_RC_TOKEN_EXPIRED:
61         ELog(0, "     XBSA: The security token has expired\n");
62         break;
63     case ADSM_RC_PSWD_GEN:
64         if (XBSA_GET_SERVER_TYPE(info->serverType) == XBSA_SERVER_TYPE_ADSM) {
65             ELog(0, "     XBSA: Password generation is not supported\n");
66         }
67         break;
68     case BSA_RC_BAD_HANDLE:
69         ELog(0, "     XBSA: The handle is invalid, %d\n", info->bsaHandle);
70         break;
71     case BSA_RC_NO_MATCH:
72         ELog(0,
73              "     XBSA: There were no matches found for the specified object\n");
74         break;
75     case BSA_RC_MORE_DATA:
76         ELog(0, "     XBSA: There were more matches found than expected\n");
77         break;
78     case BSA_RC_NULL_OBJNAME:
79         ELog(0, "     XBSA: The object name is null\n");
80         break;
81     case BSA_RC_OBJNAME_TOO_LONG:
82         ELog(0, "     XBSA: The object name was longer than expected\n");
83         break;
84     case BSA_RC_DESC_TOO_LONG:
85         ELog(0,
86              "     XBSA: The description string was longer than expected\n");
87         break;
88     case BSA_RC_OBJINFO_TOO_LONG:
89         ELog(0,
90              "     XBSA: The object info string was longer than expected\n");
91         break;
92     case BSA_RC_ABORT_ACTIVE_NOT_FOUND:
93         ELog(0, "     XBSA: The specified object was not found\n");
94         break;
95     case BSA_RC_NULL_DATABLKPTR:
96         ELog(0, "     XBSA: The dataBlockPtr is null\n");
97         break;
98     case BSA_RC_INVALID_VOTE:
99         ELog(0, "     XBSA: The vote variable is invalid\n");
100         break;
101     }
102 }
103
104 /*
105  * Hook into the correct XBSA shared library.
106  * Set up the function pointers.
107  * Get the library version.
108  * XBSAQueryApiVersion
109  */
110 afs_int32
111 xbsa_MountLibrary(struct butx_transactionInfo *info, afs_int32 serverType)
112 {
113     void *dynlib;
114     int rc;
115
116     if (debugLevel > 98) {
117         printf("\nxbsa_MountLibraray\n");
118     }
119
120     switch (serverType) {
121     case XBSA_SERVER_TYPE_ADSM:
122 #if defined(AFS_AIX_ENV)
123         dynlib =
124             dlopen("/usr/lib/libXApi.a(bsashr10.o)",
125                    RTLD_NOW | RTLD_LOCAL | RTLD_MEMBER);
126         if (dynlib == NULL) {
127             dynlib =
128                 dlopen("/usr/lib/libXApi.a(xbsa.o)",
129                        RTLD_NOW | RTLD_LOCAL | RTLD_MEMBER);
130         }
131 #elif defined(AFS_SUN5_ENV)
132         dynlib = dlopen("/usr/lib/libXApi.so", RTLD_NOW | RTLD_LOCAL);
133 #else
134         dynlib = NULL;
135 #endif
136         break;
137     default:
138         ELog(0, "xbsa_MountLibrary: The serverType %d is not recognized\n",
139              serverType);
140         return (BUTX_INVALIDSERVERTYPE);
141         break;
142     }
143
144     if (dynlib == NULL) {
145         ELog(0,
146              "xbsa_MountLibrary: The dlopen call to load the XBSA shared library failed\n");
147         return (BUTX_NOLIBRARY);
148     }
149
150     memset(info, 0, sizeof(struct butx_transactionInfo));
151     XBSA_SET_SERVER_TYPE(info->serverType, serverType);
152
153 #if defined(AFS_AIX_ENV) || defined(AFS_SUN5_ENV)
154     XBSAInit = (BSA_Int16(*)
155                 (BSA_UInt32 *, SecurityToken *, ObjectOwner *,
156                  char **))dlsym((void *)dynlib, "BSAInit");
157     XBSABeginTxn =
158         (BSA_Int16(*)(BSA_UInt32)) dlsym((void *)dynlib, "BSABeginTxn");
159     XBSAEndTxn =
160         (BSA_Int16(*)(BSA_UInt32, Vote)) dlsym((void *)dynlib, "BSAEndTxn");
161     XBSATerminate =
162         (BSA_Int16(*)(BSA_UInt32)) dlsym((void *)dynlib, "BSATerminate");
163     XBSAQueryObject =
164         (BSA_Int16(*)(BSA_UInt32, QueryDescriptor *, ObjectDescriptor *))
165         dlsym((void *)dynlib, "BSAQueryObject");
166     XBSAGetObject =
167         (BSA_Int16(*)(BSA_UInt32, ObjectDescriptor *, DataBlock *))
168         dlsym((void *)dynlib, "BSAGetObject");
169     XBSAEndData =
170         (BSA_Int16(*)(BSA_UInt32)) dlsym((void *)dynlib, "BSAEndData");
171     XBSACreateObject =
172         (BSA_Int16(*)(BSA_UInt32, ObjectDescriptor *, DataBlock *))
173         dlsym((void *)dynlib, "BSACreateObject");
174     XBSAMarkObjectInactive =
175         (BSA_Int16(*)(BSA_UInt32, ObjectName *)) dlsym((void *)dynlib,
176                                                        "BSAMarkObjectInactive");
177     XBSADeleteObject =
178         (BSA_Int16(*)(BSA_UInt32, CopyType, ObjectName *, CopyId *))
179         dlsym((void *)dynlib, "BSADeleteObject");
180     XBSASendData =
181         (BSA_Int16(*)(BSA_UInt32, DataBlock *)) dlsym((void *)dynlib,
182                                                       "BSASendData");
183     XBSAGetData =
184         (BSA_Int16(*)(BSA_UInt32, DataBlock *)) dlsym((void *)dynlib,
185                                                       "BSAGetData");
186     XBSAQueryApiVersion =
187         (BSA_Int16(*)(ApiVersion *)) dlsym((void *)dynlib,
188                                            "BSAQueryApiVersion");
189     XBSAGetEnvironment =
190         (BSA_Int16(*)(BSA_UInt32, ObjectOwner *, char **))dlsym((void *)
191                                                                 dynlib,
192                                                                 "BSAGetEnvironment");
193
194     if (!XBSAInit || !XBSABeginTxn || !XBSAEndTxn || !XBSATerminate
195         || !XBSAQueryObject || !XBSAGetObject || !XBSAEndData
196         || !XBSACreateObject || !XBSADeleteObject || !XBSAMarkObjectInactive
197         || !XBSASendData || !XBSAGetData || !XBSAQueryApiVersion
198         || !XBSAGetEnvironment) {
199         ELog(0,
200              "xbsa_MountLibrary: The dlopen call to load the XBSA shared library failed\n");
201         return (BUTX_NOLIBRARY);
202     }
203
204     XBSAQueryApiVersion(&(info->apiVersion));
205 #endif
206
207     /*
208      * Verify the API version
209      */
210     if ((info->apiVersion.version == XBSA_TS_VERSION)
211         && (info->apiVersion.release == XBSA_TS_RELEASE)) {
212         /* XOPEN Techincal Standard Level! 
213          * We are coded to the Preliminary Spec!  Time to go boom!
214          */
215         ELog(0,
216              "xbsa_MountLibrary: The XBSAQueryApiVersion call returned an incompatible version, %d %d %d\n",
217              info->apiVersion.version, info->apiVersion.release,
218              info->apiVersion.level);
219         return (BUTX_INVALIDVERSION);
220     }
221
222     switch (XBSA_GET_SERVER_TYPE(info->serverType)) {
223     case XBSA_SERVER_TYPE_ADSM:
224         if ((info->apiVersion.version > XBSA_ADSM_NO_MULT_SERVER_VERSION)
225             || (info->apiVersion.version == XBSA_ADSM_NO_MULT_SERVER_VERSION
226                 && info->apiVersion.release >
227                 XBSA_ADSM_NO_MULT_SERVER_RELEASE)
228             || (info->apiVersion.version == XBSA_ADSM_NO_MULT_SERVER_VERSION
229                 && info->apiVersion.release ==
230                 XBSA_ADSM_NO_MULT_SERVER_RELEASE
231                 && info->apiVersion.level > XBSA_ADSM_NO_MULT_SERVER_LEVEL)) {
232
233             /* This version contains the fixes to allow multiple servers */
234             info->serverType |= XBSA_SERVER_FLAG_MULTIPLE;
235         } else {
236             /* This is an older version of ADSM prior to the fix to
237              * allow multiple servers.
238              */
239             info->serverType |= XBSA_SERVER_FLAG_NONE;
240         }
241         break;
242     }
243
244     return (XBSA_SUCCESS);
245
246 }
247
248 /*
249  * Set up the connection to the XBSA Server.
250  * BSAInit
251  * BSAGetEnvironment
252  */
253 afs_int32
254 xbsa_Initialize(struct butx_transactionInfo * info, char *bsaObjectOwner,
255                 char *appObjectOwner, char *secToken, char *serverName)
256 {
257     char envStrs[XBSA_NUM_ENV_STRS][BSA_MAX_DESC];
258     char *envP[XBSA_NUM_ENV_STRS + 1];
259     char *ADSMMaxObject = "MAXOBJ=";
260     char *ADSMServer = "DSMSRVR=";
261     char *tempStrPtr;
262     int i;
263     int rc;
264
265     if (debugLevel > 98) {
266         printf("\nxbsa_Initialize bsaObjectOwner='%s' appObjectOwner='%s' "
267                "secToken=xxxxxx servername='%s'\n", GOODSTR(bsaObjectOwner),
268                GOODSTR(appObjectOwner), GOODSTR(serverName));
269     }
270
271     if (info->bsaHandle != 0) {
272         /* We already have a handle */
273         ELog(0,
274              "xbsa_Initialize: The dlopen call to load the XBSA shared library failed\n");
275         return (BUTX_ILLEGALINIT);
276     }
277
278     /*
279      * The XBSAGetEnvironment function is supposed to return the
280      * the serverName to use.  However, it is returning the tcpserveraddress
281      * instead.  So, we can't count on this function to properly fill it
282      * in.  So, until that get fixed.  The serverName will have to be filled
283      * in by the callers of this function (butc).
284      */
285
286     /* Initialize the environment strings */
287     for (i = 0; i < XBSA_NUM_ENV_STRS; i++)
288         envP[i] = envStrs[i];
289     envP[XBSA_NUM_ENV_STRS] = NULL;
290
291     /* The environment variables are specific to the server type */
292     switch (XBSA_GET_SERVER_TYPE(info->serverType)) {
293     case XBSA_SERVER_TYPE_ADSM:
294         if (serverName) {
295             if (strlen(serverName) >= BSA_MAX_DESC) {
296                 ELog(0,
297                      "xbsa_Initialize: The serverName was not specified\n");
298                 return (BUTX_INVALIDSERVERNAME);
299             }
300             strcpy(info->serverName, serverName);
301             strcpy(envP[0], ADSMServer);
302             tempStrPtr = envP[0];
303             tempStrPtr = tempStrPtr + strlen(ADSMServer);
304             strcat(tempStrPtr, serverName);
305             envP[1] = NULL;
306         } else {
307             envP[0] = NULL;
308             ELog(0, "xbsa_Initialize: The serverName was not specified\n");
309             return (BUTX_INVALIDSERVERNAME);
310         }
311         break;
312     default:
313         ELog(0, "xbsa_Initialize: The serverType %d is not recognized\n",
314              XBSA_GET_SERVER_TYPE(info->serverType));
315         return (BUTX_INVALIDSERVERTYPE);
316         break;
317     }
318
319     if (bsaObjectOwner) {
320         if (strlen(bsaObjectOwner) >= BSA_MAX_BSAOBJECT_OWNER) {
321             ELog(0,
322                  "xbsa_Initialize: The bsaObjectOwner is too long; size = %d; name = %s\n",
323                  strlen(bsaObjectOwner), bsaObjectOwner);
324             return (BUTX_INVALIDBSANAME);
325         }
326         strcpy(info->objOwner.bsaObjectOwner, bsaObjectOwner);
327     } else {
328         info->objOwner.bsaObjectOwner[0] = NULL;
329     }
330
331     if (appObjectOwner) {
332         if (strlen(appObjectOwner) >= BSA_MAX_APPOBJECT_OWNER) {
333             ELog(0,
334                  "xbsa_Initialize: The appObjectOwner is too long; size = %d; name = %s\n",
335                  strlen(appObjectOwner), appObjectOwner);
336             return (BUTX_INVALIDAPPNAME);
337         }
338         strcpy(info->objOwner.appObjectOwner, appObjectOwner);
339     } else {
340         info->objOwner.appObjectOwner[0] = NULL;
341     }
342
343     if (secToken) {
344         if (strlen(secToken) >= BSA_MAX_TOKEN_SIZE) {
345             ELog(0,
346                  "xbsa_Initialize: The secToken is too long; size = %d; name = %s\n",
347                  strlen(secToken), secToken);
348             return (BUTX_INVALIDSECTOKEN);
349         }
350         strcpy(info->secToken, secToken);
351     } else {
352         info->secToken[0] = NULL;
353     }
354
355     rc = (int)XBSAInit(&(info->bsaHandle), &(info->secToken),
356                        &(info->objOwner), envP);
357     if (rc != BSA_RC_SUCCESS) {
358         ELog(0, "xbsa_Initialize: The XBSAInit call failed with %d\n", rc);
359         xbsa_error(rc, info);
360         return (BUTX_INITFAIL);
361     }
362
363     /* Initialize the environment strings */
364     for (i = 0; i < XBSA_NUM_ENV_STRS; i++)
365         envP[i] = envStrs[i];
366     envP[XBSA_NUM_ENV_STRS] = NULL;
367
368     rc = (int)XBSAGetEnvironment(info->bsaHandle, &info->objOwner, envP);
369     if (rc != BSA_RC_SUCCESS) {
370         ELog(0,
371              "xbsa_Initialize: The XBSAGetEnvironment call failed with %d\n",
372              rc);
373         xbsa_error(rc, info);
374         return (BUTX_GETENVFAIL);
375     }
376
377     switch (XBSA_GET_SERVER_TYPE(info->serverType)) {
378     case XBSA_SERVER_TYPE_ADSM:
379         for (i = 0; i < XBSA_NUM_ENV_STRS; i++) {
380             if (strncmp(envP[i], ADSMMaxObject, sizeof(ADSMMaxObject)) == 0) {
381                 tempStrPtr = envP[i];
382                 tempStrPtr = tempStrPtr + strlen(ADSMMaxObject);
383                 info->maxObjects = strtol(tempStrPtr, NULL, 10);
384                 if (info->maxObjects <= 0) {
385                     ELog(0,
386                          "xbsa_Initialize: The XBSAGetEnvironment call returned an invalid value for MAXOBJ %d\n",
387                          info->maxObjects);
388                     return (BUTX_GETENVFAIL);
389                 }
390             }
391         }
392         if (info->maxObjects == 0) {
393             ELog(0,
394                  "xbsa_Initialize: The XBSAGetEnvironment call failed to return the MAXOBJ string\n");
395             return (BUTX_GETENVFAIL);
396         }
397         break;
398     }
399
400     return (XBSA_SUCCESS);
401 }
402
403 /*
404  * Create a transaction
405  * BSABeginTxn
406  */
407 afs_int32
408 xbsa_BeginTrans(struct butx_transactionInfo * info)
409 {
410     int rc;
411
412     if (debugLevel > 98) {
413         printf("\nxbsa_BeginTrans\n");
414         printf
415             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
416              GOODSTR(info->serverName),
417              GOODSTR(info->objOwner.bsaObjectOwner),
418              GOODSTR(info->objOwner.appObjectOwner));
419     }
420
421     if (info->bsaHandle == 0) {
422         /* We haven't initialized yet! */
423         ELog(0, "xbsa_BeginTrans: No current handle, butx not initialized\n");
424         return (BUTX_NOHANDLE);
425     }
426
427     rc = (int)XBSABeginTxn(info->bsaHandle);
428     if (rc != BSA_RC_SUCCESS) {
429         ELog(0, "xbsa_BeginTrans: The XBSABeginTxn call failed with %d\n",
430              rc);
431         xbsa_error(rc, info);
432         return (BUTX_BEGINTXNFAIL);
433     }
434
435     info->numObjects = 0;
436     return (XBSA_SUCCESS);
437 }
438
439 /*
440  * End the current transaction
441  * BSAEndTxn
442  */
443 afs_int32
444 xbsa_EndTrans(struct butx_transactionInfo * info)
445 {
446     int rc;
447
448     if (debugLevel > 98) {
449         printf("\nxbsa_EndTrans\n");
450         printf
451             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
452              GOODSTR(info->serverName),
453              GOODSTR(info->objOwner.bsaObjectOwner),
454              GOODSTR(info->objOwner.appObjectOwner));
455     }
456
457     if (info->bsaHandle == 0) {
458         /* We haven't initialized yet! */
459         ELog(0, "xbsa_EndTrans: No current handle, butx not initialized\n");
460         return (BUTX_NOHANDLE);
461     }
462
463     /* terminate the transaction */
464     rc = (int)XBSAEndTxn(info->bsaHandle, BSAVote_COMMIT);
465     if (rc != BSA_RC_SUCCESS) {
466         ELog(0, "xbsa_EndTrans: The XBSAEndTxn call failed with %d\n", rc);
467         xbsa_error(rc, info);
468         return (BUTX_ENDTXNFAIL);
469     }
470     return (XBSA_SUCCESS);
471 }
472
473 /*
474  * Terminate the connection to the XBSA Server.
475  * End the transaction.
476  * BSATerminate
477  */
478 afs_int32
479 xbsa_Finalize(struct butx_transactionInfo * info)
480 {
481     int rc;
482
483     if (debugLevel > 98) {
484         printf("\nxbsa_Finalize\n");
485         printf
486             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
487              GOODSTR(info->serverName),
488              GOODSTR(info->objOwner.bsaObjectOwner),
489              GOODSTR(info->objOwner.appObjectOwner));
490     }
491
492     if (info->bsaHandle == 0) {
493         /* We haven't initialized yet! */
494         ELog(0, "xbsa_Finalize: No current handle, butx not initialized\n");
495         return (BUTX_NOHANDLE);
496     }
497
498     /* terminate the session */
499     rc = (int)XBSATerminate(info->bsaHandle);
500     if (rc != BSA_RC_SUCCESS) {
501         ELog(0, "The XBSATerminate call failed with %d\n", rc);
502         xbsa_error(rc, info);
503         return (BUTX_TERMFAIL);
504     }
505
506     info->bsaHandle = 0;
507     return (XBSA_SUCCESS);
508 }
509
510 /*
511  * Query for the object we are looking for.
512  * BSAQueryObject
513  */
514 afs_int32
515 xbsa_QueryObject(struct butx_transactionInfo * info, char *objectSpaceName,
516                  char *pathName)
517 {
518     int rc;
519     QueryDescriptor queryDescriptor;
520
521     if (debugLevel > 98) {
522         printf("\nxbsa_QueryObject objectSpaceName='%s' pathnName='%s'\n",
523                GOODSTR(objectSpaceName), GOODSTR(pathName));
524         printf
525             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
526              GOODSTR(info->serverName),
527              GOODSTR(info->objOwner.bsaObjectOwner),
528              GOODSTR(info->objOwner.appObjectOwner));
529     }
530
531     if (info->bsaHandle == 0) {
532         /* We haven't initialized yet! */
533         ELog(0,
534              "xbsa_QueryObject: No current handle, butx not initialized\n");
535         return (BUTX_NOHANDLE);
536     }
537
538     /* Initialize the query for our dump name */
539
540     if (objectSpaceName) {
541         if (strlen(objectSpaceName) >= BSA_MAX_OSNAME) {
542             ELog(0,
543                  "xbsa_QueryObject: The objectSpaceName is too long; size = %d; name = %s\n",
544                  strlen(objectSpaceName), objectSpaceName);
545             return (BUTX_INVALIDOBJECTSPNAME);
546         }
547         strcpy(queryDescriptor.objName.objectSpaceName, objectSpaceName);
548     } else {
549         queryDescriptor.objName.objectSpaceName[0] = NULL;
550     }
551
552     if (pathName) {
553         if (strlen(pathName) >= BSA_MAX_PATHNAME) {
554             ELog(0,
555                  "xbsa_QueryObject: The pathName is too long; size = %d; name = %s\n",
556                  strlen(pathName), pathName);
557             return (BUTX_INVALIDPATHNAME);
558         }
559         strcpy(queryDescriptor.objName.pathName, pathName);
560     } else {
561         queryDescriptor.objName.pathName[0] = NULL;
562     }
563
564     queryDescriptor.owner = info->objOwner;
565     queryDescriptor.copyType = BSACopyType_BACKUP;
566     strcpy(queryDescriptor.lGName, "");
567     strcpy(queryDescriptor.cGName, "");
568     strcpy(queryDescriptor.resourceType, "");
569     queryDescriptor.objectType = BSAObjectType_FILE;
570     queryDescriptor.status = BSAObjectStatus_ACTIVE;
571     strcpy(queryDescriptor.desc, "");
572
573     rc = (int)XBSAQueryObject(info->bsaHandle, &queryDescriptor,
574                               &info->curObject);
575     if (rc == BSA_RC_NO_MORE_DATA)
576         rc = BSA_RC_SUCCESS;    /* This is actually a success! */
577     if (rc != BSA_RC_SUCCESS) {
578         ELog(0, "xbsa_QueryObject: The xBSAQueryObject call failed with %d\n",
579              rc);
580         xbsa_error(rc, info);
581         return (BUTX_QUERYFAIL);
582     }
583     return (XBSA_SUCCESS);
584 }
585
586 /*
587  * Locate the correct object on the server and then make the call to
588  * get the object descriptor so we can begin the transfer of data.
589  * BSAGetObject
590  */
591 afs_int32
592 xbsa_ReadObjectBegin(struct butx_transactionInfo * info, char *dataBuffer,
593                      afs_int32 bufferSize, afs_int32 * count,
594                      afs_int32 * endOfData)
595 {
596     int rc;
597     DataBlock dataBlock;
598
599     if (debugLevel > 98) {
600         printf("\nxbsa_ReadObjectBegin %d Bytes\n", bufferSize);
601         printf
602             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
603              GOODSTR(info->serverName),
604              GOODSTR(info->objOwner.bsaObjectOwner),
605              GOODSTR(info->objOwner.appObjectOwner));
606     }
607
608     if (info->bsaHandle == 0) {
609         /* We haven't initialized yet! */
610         ELog(0,
611              "xbsa_ReadObjectBegin: No current handle, butx not initialized\n");
612         return (BUTX_NOHANDLE);
613     }
614
615     if ((bufferSize < 0) || (bufferSize > XBSAMAXBUFFER)) {
616         ELog(0, "xbsa_ReadObjectBegin: The bufferSize %d is invalid\n",
617              bufferSize);
618         return (BUTX_INVALIDBUFFERSIZE);
619     }
620
621     if (dataBuffer == NULL) {
622         ELog(0, "xbsa_ReadObjectBegin: The dataBuffer is NULL\n");
623         return (BUTX_INVALIDDATABUFFER);
624     }
625
626     dataBlock.bufferLen = (BSA_UInt16) bufferSize;
627     dataBlock.numBytes = (BSA_UInt16) 0;
628     dataBlock.bufferPtr = dataBuffer;
629     *endOfData = 0;
630
631     rc = (int)XBSAGetObject(info->bsaHandle, &info->curObject, &dataBlock);
632     if ((rc != BSA_RC_MORE_DATA) && (rc != BSA_RC_NO_MORE_DATA)) {
633         ELog(0,
634              "xbsa_ReadObjectBegin: The XBSAGetObject call failed with %d\n",
635              rc);
636         xbsa_error(rc, info);
637         return (BUTX_GETOBJFAIL);
638     }
639     *count = dataBlock.numBytes;
640     if (rc == BSA_RC_NO_MORE_DATA)
641         *endOfData = 1;
642     return (XBSA_SUCCESS);
643 }
644
645
646 /*
647  * Tell the XBSA Server that this is the end of Data for this object.
648  * BSAEndData()
649  */
650 afs_int32
651 xbsa_ReadObjectEnd(struct butx_transactionInfo * info)
652 {
653     int rc;
654
655     if (debugLevel > 98) {
656         printf("\nxbsa_ReadObjectEnd\n");
657         printf
658             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
659              GOODSTR(info->serverName),
660              GOODSTR(info->objOwner.bsaObjectOwner),
661              GOODSTR(info->objOwner.appObjectOwner));
662     }
663
664     if (info->bsaHandle == 0) {
665         /* We haven't initialized yet! */
666         ELog(0,
667              "xbsa_ReadObjectEnd: No current handle, butx not initialized\n");
668         return (BUTX_NOHANDLE);
669     }
670     rc = (int)XBSAEndData(info->bsaHandle);
671     if (rc != BSA_RC_SUCCESS) {
672         ELog(0, "xbsa_ReadObjectEnd: XBSAEndData call failed with %d\n", rc);
673         xbsa_error(rc, info);
674         return (BUTX_ENDDATAFAIL);
675     }
676     return (XBSA_SUCCESS);
677 }
678
679
680 /*
681  * Create the XBSA Backup Copy Object.
682  * BSACreateObject
683  */
684 afs_int32
685 xbsa_WriteObjectBegin(struct butx_transactionInfo * info,
686                       char *objectSpaceName, char *pathName, char *lGName,
687                       afs_hyper_t estimatedSize, char *objectDescription,
688                       char *objectInfo)
689 {
690     int rc;
691     int length;
692     DataBlock dataBlock;
693
694     if (debugLevel > 98) {
695         printf
696             ("\nxbsa_WriteObjectBegin objectSpacename='%s' pathName='%s' lGName='%s' "
697              "estimatesSize='0x%x%08x objectDescription='%s' objectInfo='%s'\n",
698              GOODSTR(objectSpaceName), GOODSTR(pathName), GOODSTR(lGName),
699              hgethi(estimatedSize), hgetlo(estimatedSize),
700              GOODSTR(objectDescription), GOODSTR(objectInfo));
701         printf
702             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
703              GOODSTR(info->serverName),
704              GOODSTR(info->objOwner.bsaObjectOwner),
705              GOODSTR(info->objOwner.appObjectOwner));
706     }
707
708     if (info->bsaHandle == 0) {
709         /* We haven't initialized yet! */
710         ELog(0,
711              "xbsa_WriteObjectBegin: No current handle, butx not initialized\n");
712         return (BUTX_NOHANDLE);
713     }
714
715     if (objectSpaceName) {
716         if (strlen(objectSpaceName) >= BSA_MAX_OSNAME) {
717             ELog(0,
718                  "xbsa_WriteObjectBegin: The objectSpaceName is too long; size = %d; name = %s\n",
719                  strlen(objectSpaceName), objectSpaceName);
720             return (BUTX_INVALIDOBJECTSPNAME);
721         }
722         strcpy(info->curObject.objName.objectSpaceName, objectSpaceName);
723     } else {
724         info->curObject.objName.objectSpaceName[0] = NULL;
725     }
726
727     if (pathName) {
728         if (strlen(pathName) >= BSA_MAX_PATHNAME) {
729             ELog(0,
730                  "xbsa_WriteObjectBegin: The pathName is too long; size = %d; name = %s\n",
731                  strlen(pathName), pathName);
732             return (BUTX_INVALIDPATHNAME);
733         }
734         strcpy(info->curObject.objName.pathName, pathName);
735     } else {
736         info->curObject.objName.pathName[0] = NULL;
737     }
738
739     if (lGName) {
740         if (strlen(lGName) >= BSA_MAX_LG_NAME) {
741             ELog(0,
742                  "xbsa_WriteObjectBegin: The lGName is too long; size = %d; name = %s\n",
743                  strlen(lGName), lGName);
744             return (BUTX_INVALIDLGNAME);
745         }
746         strcpy(info->curObject.lGName, lGName);
747     } else {
748         info->curObject.lGName[0] = NULL;
749     }
750
751     if (objectDescription) {
752         if (((XBSA_GET_SERVER_TYPE(info->serverType) == XBSA_SERVER_TYPE_ADSM)
753              && (strlen(objectDescription) >= ADSM_MAX_DESC))
754             ||
755             ((XBSA_GET_SERVER_TYPE(info->serverType) != XBSA_SERVER_TYPE_ADSM)
756              && (strlen(objectDescription) >= BSA_MAX_DESC))) {
757             ELog(0,
758                  "xbsa_WriteObjectBegin: The objectDescription is too long; size = %d; name = %s\n",
759                  strlen(objectDescription), objectDescription);
760             return (BUTX_INVALIDOBJDESC);
761         }
762         strcpy(info->curObject.desc, objectDescription);
763     } else {
764         info->curObject.desc[0] = NULL;
765     }
766
767     if (objectInfo) {
768         if (((XBSA_GET_SERVER_TYPE(info->serverType) == XBSA_SERVER_TYPE_ADSM)
769              && (strlen(objectInfo) >= ADSM_MAX_OBJINFO))
770             ||
771             ((XBSA_GET_SERVER_TYPE(info->serverType) != XBSA_SERVER_TYPE_ADSM)
772              && (strlen(objectInfo) >= BSA_MAX_OBJINFO))) {
773             ELog(0,
774                  "xbsa_WriteObjectBegin: The objectInfo is too long; size = %d; name = %s\n",
775                  strlen(objectInfo), objectInfo);
776             return (BUTX_INVALIDOBJINFO);
777         }
778         strcpy(info->curObject.objectInfo, objectInfo);
779     } else {
780         info->curObject.objectInfo[0] = NULL;
781     }
782
783     if (info->numObjects == info->maxObjects) {
784         /* If we've used up Max Objects we must start a new transaction. */
785         rc = (int)xbsa_EndTrans(info);
786         if (rc != XBSA_SUCCESS) {
787             return (rc);
788         }
789         rc = (int)xbsa_BeginTrans(info);
790         if (rc != XBSA_SUCCESS) {
791             return (rc);
792         }
793     }
794
795     dataBlock.bufferLen = (BSA_UInt16) 0;
796     dataBlock.numBytes = (BSA_UInt16) 0;
797     dataBlock.bufferPtr = 0;
798
799     info->curObject.Owner = info->objOwner;
800     info->curObject.copyType = BSACopyType_BACKUP;
801     info->curObject.size.left = hgethi(estimatedSize);
802     info->curObject.size.right = hgetlo(estimatedSize);
803     info->curObject.objectType = BSAObjectType_FILE;
804     strcpy(info->curObject.resourceType, resourceType);
805
806     rc = (int)XBSACreateObject(info->bsaHandle, &info->curObject, &dataBlock);
807     if (rc != BSA_RC_SUCCESS) {
808         ELog(0,
809              "xbsa_WriteObjectBegin: The XBSACreateObject call failed with %d\n",
810              rc);
811         xbsa_error(rc, info);
812         return (BUTX_CREATEOBJFAIL);
813     }
814
815     info->numObjects++;
816
817     return (XBSA_SUCCESS);
818 }
819
820 /*
821  * Delete a backup object from the server
822  * BSAMarkObjectInactive()
823  * BSADeleteObject()
824  */
825 afs_int32
826 xbsa_DeleteObject(struct butx_transactionInfo * info, char *objectSpaceName,
827                   char *pathName)
828 {
829     int rc;
830     ObjectName objectName;
831
832     if (debugLevel > 98) {
833         printf("\nxbsa_DeleteObject objectSpacename='%s' pathName='%s'\n",
834                GOODSTR(objectSpaceName), GOODSTR(pathName));
835         printf
836             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
837              GOODSTR(info->serverName),
838              GOODSTR(info->objOwner.bsaObjectOwner),
839              GOODSTR(info->objOwner.appObjectOwner));
840     }
841
842     if (info->bsaHandle == 0) {
843         /* We haven't initialized yet! */
844         ELog(0,
845              "xbsa_DeleteObject: No current handle, butx not initialized\n");
846         return (BUTX_NOHANDLE);
847     }
848
849     if (objectSpaceName) {
850         if (strlen(objectSpaceName) >= BSA_MAX_OSNAME) {
851             ELog(0,
852                  "xbsa_DeleteObject: The objectSpaceName is too long; size = %d; name = %s\n",
853                  strlen(objectSpaceName), objectSpaceName);
854             return (BUTX_INVALIDOBJECTSPNAME);
855         }
856         strcpy(objectName.objectSpaceName, objectSpaceName);
857     } else {
858         objectName.objectSpaceName[0] = NULL;
859     }
860
861     if (pathName) {
862         if (strlen(pathName) >= BSA_MAX_PATHNAME) {
863             ELog(0, "xbsa_DeleteObject: strlen(pathName), pathName\n",
864                  strlen(pathName), pathName);
865             return (BUTX_INVALIDPATHNAME);
866         }
867         strcpy(objectName.pathName, pathName);
868     } else {
869         objectName.pathName[0] = NULL;
870     }
871
872     rc = (int)XBSAMarkObjectInactive(info->bsaHandle, &objectName);
873     if (rc != BSA_RC_SUCCESS) {
874         ELog(0,
875              "xbsa_DeleteObject: XBSAMarkObjectInactive call failed with %d\n",
876              rc);
877         xbsa_error(rc, info);
878         return ((rc ==
879                  BSA_RC_ABORT_ACTIVE_NOT_FOUND) ? BUTX_DELETENOVOL :
880                 BUTX_DELETEOBJFAIL);
881     }
882
883     return (XBSA_SUCCESS);
884 }
885
886 /*
887  * Tell the XBSA Server that this is the end of Data for this object.
888  * BSAEndData()
889  */
890 afs_int32
891 xbsa_WriteObjectEnd(struct butx_transactionInfo * info)
892 {
893     int rc;
894
895     if (debugLevel > 98) {
896         printf("\nxbsa_WriteObjectEnd\n");
897         printf
898             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
899              GOODSTR(info->serverName),
900              GOODSTR(info->objOwner.bsaObjectOwner),
901              GOODSTR(info->objOwner.appObjectOwner));
902     }
903
904     if (info->bsaHandle == 0) {
905         /* We haven't initialized yet! */
906         ELog(0,
907              "xbsa_WriteObjectEnd: No current handle, butx not initialized\n");
908         return (BUTX_NOHANDLE);
909     }
910     rc = (int)XBSAEndData(info->bsaHandle);
911     if (rc != BSA_RC_SUCCESS) {
912         ELog(0, "xbsa_WriteObjectEnd: XBSAEndData call failed with %d\n", rc);
913         xbsa_error(rc, info);
914         return (BUTX_ENDDATAFAIL);
915     }
916
917     return (XBSA_SUCCESS);
918 }
919
920
921 /*
922  * Write the fileset data to the XBSA server
923  * BSASendData
924  */
925 afs_int32
926 xbsa_WriteObjectData(struct butx_transactionInfo * info, char *dataBuffer,
927                      afs_int32 bufferSize, afs_int32 * count)
928 {
929     int rc;
930     DataBlock dataBlock;
931
932     if (debugLevel > 98) {
933         printf("\nxbsa_WriteObjectData %d Bytes\n", bufferSize);
934         printf
935             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
936              GOODSTR(info->serverName),
937              GOODSTR(info->objOwner.bsaObjectOwner),
938              GOODSTR(info->objOwner.appObjectOwner));
939     }
940
941     if (info->bsaHandle == 0) {
942         /* We haven't initialized yet! */
943         ELog(0,
944              "xbsa_WriteObjectData: No current handle, butx not initialized\n");
945         return (BUTX_NOHANDLE);
946     }
947
948     if ((bufferSize < 0) || (bufferSize > XBSAMAXBUFFER)) {
949         ELog(0, "xbsa_WriteObjectData: The bufferSize %d is invalid\n",
950              bufferSize);
951         return (BUTX_INVALIDBUFFERSIZE);
952     }
953
954     if (dataBuffer == NULL) {
955         ELog(0, "xbsa_WriteObjectData: The dataBuffer is NULL\n");
956         return (BUTX_INVALIDDATABUFFER);
957     }
958
959     dataBlock.bufferPtr = dataBuffer;
960     dataBlock.bufferLen = (BSA_UInt16) bufferSize;
961     dataBlock.numBytes = (BSA_UInt16) 0;
962
963     rc = (int)XBSASendData(info->bsaHandle, &dataBlock);
964     if (rc != BSA_RC_SUCCESS) {
965         ELog(0, "xbsa_WriteObjectData: XBSAEndData call failed with %d\n",
966              rc);
967         xbsa_error(rc, info);
968         return (BUTX_SENDDATAFAIL);
969     }
970     *count = dataBlock.numBytes;
971     return (XBSA_SUCCESS);
972 }
973
974
975 /*
976  * Read the fileset data from the XBSA server
977  * BSAGetData
978  */
979 afs_int32
980 xbsa_ReadObjectData(struct butx_transactionInfo * info, char *dataBuffer,
981                     afs_int32 bufferSize, afs_int32 * count,
982                     afs_int32 * endOfData)
983 {
984     int rc;
985     DataBlock dataBlock;
986
987     if (debugLevel > 98) {
988         printf("\nxbsa_ReadObjectData %d Bytes\n", bufferSize);
989         printf
990             ("serverName='%s' ; bsaObjectOwner='%s' ; appObjectOwner='%s' ; sectoken=xxxxxx\n",
991              GOODSTR(info->serverName),
992              GOODSTR(info->objOwner.bsaObjectOwner),
993              GOODSTR(info->objOwner.appObjectOwner));
994     }
995
996     if (info->bsaHandle == 0) {
997         /* We haven't initialized yet! */
998         ELog(0,
999              "xbsa_ReadObjectData: No current handle, butx not initialized\n");
1000         return (BUTX_NOHANDLE);
1001     }
1002
1003     if ((bufferSize < 0) || (bufferSize > XBSAMAXBUFFER)) {
1004         ELog(0, "xbsa_ReadObjectData: The bufferSize %d is invalid\n",
1005              bufferSize);
1006         return (BUTX_INVALIDBUFFERSIZE);
1007     }
1008
1009     if (dataBuffer == NULL) {
1010         ELog(0, "xbsa_ReadObjectData: The dataBuffer is NULL\n");
1011         return (BUTX_INVALIDDATABUFFER);
1012     }
1013
1014     dataBlock.bufferLen = (BSA_UInt16) bufferSize;
1015     dataBlock.numBytes = (BSA_UInt16) 0;
1016     dataBlock.bufferPtr = dataBuffer;
1017     *endOfData = 0;
1018
1019     rc = (int)XBSAGetData(info->bsaHandle, &dataBlock);
1020     if ((rc != BSA_RC_MORE_DATA) && (rc != BSA_RC_NO_MORE_DATA)) {
1021         ELog(0, "xbsa_ReadObjectData: XBSAGetData call failed with %d\n", rc);
1022         xbsa_error(rc, info);
1023         return (BUTX_GETDATAFAIL);
1024     }
1025     *count = dataBlock.numBytes;
1026     if (rc == BSA_RC_NO_MORE_DATA)
1027         *endOfData = 1;
1028     return (XBSA_SUCCESS);
1029 }
1030 #endif /*xbsa */