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