7679985fade7bb940fdcae3d590416eb142bb42f
[openafs.git] / src / butc / tcprocs.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 /* procedures invoked by the rpc stub */
11
12 #include <afsconfig.h>
13 #include <afs/param.h>
14
15 RCSID("$Header$");
16
17 #include <sys/types.h>
18 #include <errno.h>
19 #ifdef AFS_NT40_ENV
20 #include <winsock2.h>
21 #else
22 #include <sys/file.h>
23 #include <netinet/in.h>
24 #endif
25 #include <rx/xdr.h>
26 #include <rx/rx.h>
27 #include <afs/afsint.h>
28 #include <stdio.h>
29 #include <afs/procmgmt.h>
30 #include <afs/assert.h>
31 #include <afs/prs_fs.h>
32 #include <sys/stat.h>
33 #include <afs/nfs.h>
34 #include <lwp.h>
35 #include <lock.h>
36 #include <afs/auth.h>
37 #include <afs/cellconfig.h>
38 #include <afs/keys.h>
39 #include <ubik.h>
40 #include <afs/tcdata.h>
41 #include "error_macros.h"
42 #include "butc_xbsa.h"
43 extern afs_int32 xbsaType;
44
45 callPermitted(call)
46     struct rx_call *call;
47 {
48     afs_int32                         code;
49
50     struct rx_connection        *tconn;
51     rxkad_level                  level;
52     Date                         expiration;
53     char                         name[MAXKTCNAMELEN];
54     char                         inst[MAXKTCNAMELEN];
55     char                         celn[MAXKTCREALMLEN];
56     afs_int32                         kvno;
57
58     char                        *cell;
59     afs_int32                         flag;
60
61     /* before this code can be used, the rx connection, on the bucoord side, must */
62     /* be changed so that it will set up for token passing instead of using  a    */
63     /* simple rx connection that, below, returns a value of 0 from rx_SecurityClassOf */
64     return 1;
65 }
66
67 /* -------------------------
68  * butc - interface routines - alphabetic order
69  * -------------------------
70  */
71
72 STC_LabelTape(acid, label, taskId)
73      struct rx_call *acid;
74      struct tc_tapeLabel *label;
75      afs_uint32 *taskId;
76 {
77 #ifdef AFS_PTHREAD_ENV
78     pthread_t pid;
79     pthread_attr_t tattr;
80     AFS_SIGSET_DECL;
81 #else
82     PROCESS pid;
83 #endif
84     struct tc_tapeLabel *mylabel;
85     struct labelTapeIf *ptr;
86     statusP statusPtr;
87     afs_int32 code;
88
89      extern int Labeller();
90      extern statusP createStatusNode();
91      extern afs_int32 allocTaskId();
92
93 #ifdef xbsa
94     if (CONF_XBSA) return(TC_BADTASK);    /* LabelTape does not apply if XBSA */
95 #endif
96
97     if ( callPermitted(acid) == 0 )
98         return(TC_NOTPERMITTED);
99
100     ptr = (struct labelTapeIf *) malloc(sizeof(*ptr));
101     if (!ptr) ERROR_EXIT(TC_NOMEMORY);
102     memcpy(&ptr->label, label, sizeof(ptr->label));
103
104     /* set up the status node */
105     *taskId = allocTaskId();                    /* for bucoord */
106     ptr->taskId = *taskId;
107     
108     statusPtr = createStatusNode();
109     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
110
111     lock_Status();
112     statusPtr->taskId     = *taskId;
113     statusPtr->lastPolled = time(0);
114     statusPtr->flags     &= ~STARTING;         /* ok to examine */
115     strncpy(statusPtr->taskName, "Labeltape", sizeof(statusPtr->taskName));
116     unlock_Status();
117
118     /* create the LWP to do the real work behind the scenes */
119 #ifdef AFS_PTHREAD_ENV
120     code = pthread_attr_init(&tattr);
121     if (code) ERROR_EXIT(code);
122
123     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
124     if (code) ERROR_EXIT(code);
125
126     AFS_SIGSET_CLEAR();
127     code = pthread_create(&pid, &tattr, Labeller, ptr);
128     AFS_SIGSET_RESTORE();
129 #else
130     code = LWP_CreateProcess(Labeller, 32768, 1, ptr ,"labeller process", &pid);
131 #endif
132
133 error_exit:
134     if ( code )
135     {
136         if (statusPtr) deleteStatusNode(statusPtr);
137         if (ptr) free(ptr);
138     }
139
140     return(code);
141 }
142
143 /* STC_PerformDump
144  *      Tape coordinator server routine to do a dump
145  */
146
147 STC_PerformDump(rxCallId, tcdiPtr, tc_dumpArrayPtr, taskId)
148     struct rx_call *rxCallId;
149     struct tc_dumpInterface *tcdiPtr;
150     tc_dumpArray *tc_dumpArrayPtr;
151     afs_int32 *taskId;
152 {
153     struct dumpNode *newNode = 0;
154     statusP         statusPtr = 0;
155 #ifdef AFS_PTHREAD_ENV
156     pthread_t       pid;
157     pthread_attr_t  tattr;
158     AFS_SIGSET_DECL;
159 #else
160     PROCESS         pid;
161 #endif
162     afs_int32           code = 0;
163
164     extern statusP createStatusNode();
165     extern Dumper();
166
167     if ( callPermitted(rxCallId) == 0 )
168         return(TC_NOTPERMITTED);
169
170     /* should be verifying parameter validity */
171     *taskId = 0;
172
173     /* this creates a node in list, alots an id for it and prepares it for locking */
174     CreateNode(&newNode);
175
176     /*set up the parameters in the node, to be used by LWP */
177     strcpy(newNode->dumpSetName, tcdiPtr->dumpName);
178
179     newNode->dumpName = (char *) malloc(strlen(tcdiPtr->dumpPath)+1);
180     strcpy(newNode->dumpName, tcdiPtr->dumpPath);
181
182     newNode->volumeSetName = (char *) malloc(strlen(tcdiPtr->volumeSetName)+1);
183     strcpy(newNode->volumeSetName, tcdiPtr->volumeSetName);
184
185     CopyTapeSetDesc(&(newNode->tapeSetDesc), &tcdiPtr->tapeSet);
186
187     newNode->dumps = (struct tc_dumpDesc *)
188         malloc(sizeof(struct tc_dumpDesc) * tc_dumpArrayPtr->tc_dumpArray_len);
189     newNode->arraySize = tc_dumpArrayPtr->tc_dumpArray_len;
190     CopyDumpDesc(newNode->dumps, tc_dumpArrayPtr);
191
192     newNode->parent = tcdiPtr->parentDumpId;
193     newNode->level = tcdiPtr->dumpLevel;
194     newNode->doAppend = tcdiPtr->doAppend;
195 #ifdef xbsa
196     if (CONF_XBSA) newNode->doAppend = 0;    /* Append flag is ignored if talking to XBSA */
197 #endif
198
199     /* create the status node */
200     statusPtr = createStatusNode();
201     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
202
203     lock_Status();
204     statusPtr->taskId     = newNode->taskID;
205     statusPtr->lastPolled = time(0);
206     statusPtr->flags     &= ~STARTING;                     /* ok to examine */
207     strncpy(statusPtr->taskName, "Dump", sizeof(statusPtr->taskName));
208     unlock_Status();
209
210     newNode->statusNodePtr = statusPtr;
211
212     /* create the LWP to do the real work behind the scenes */
213 #ifdef AFS_PTHREAD_ENV
214     code = pthread_attr_init(&tattr);
215     if (code) ERROR_EXIT(code);
216
217     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
218     if (code) ERROR_EXIT(code);
219
220     AFS_SIGSET_CLEAR();
221     code = pthread_create(&pid, &tattr, Dumper, newNode);
222     AFS_SIGSET_RESTORE();
223 #else
224     code = LWP_CreateProcess(Dumper, 32768, 1, newNode, "dumper process", &pid);
225 #endif
226     if (code) ERROR_EXIT(code);
227
228     *taskId = newNode->taskID;
229
230 error_exit:
231     if (code)
232     {
233         if (statusPtr) deleteStatusNode(statusPtr);
234         FreeNode(newNode->taskID);      /*  failed to create LWP to do the dump. */
235     }
236
237     return(code);
238 }
239
240 STC_PerformRestore(acid, dumpSetName, arestores, taskID)
241      struct rx_call *acid;
242      char *dumpSetName;               /* not used */
243      tc_restoreArray *arestores;
244      afs_int32 *taskID;
245 {
246     struct dumpNode *newNode;
247     statusP statusPtr;
248     afs_int32 code = 0;
249 #ifdef AFS_PTHREAD_ENV
250     pthread_t pid;
251     pthread_attr_t tattr;
252     AFS_SIGSET_DECL;
253 #else
254     PROCESS pid;
255 #endif
256
257     extern int Restorer();
258     extern statusP createStatusNode();
259
260     if ( callPermitted(acid) == 0 )
261         return(TC_NOTPERMITTED);
262
263     /* should  verify parameter validity */
264
265     /* this creates a node in list, alots an id for it and prepares it for locking */
266     CreateNode(&newNode);
267
268     newNode->restores = (struct tc_restoreDesc *)
269         malloc (sizeof(struct tc_restoreDesc) * arestores->tc_restoreArray_len);
270     newNode->arraySize = arestores->tc_restoreArray_len;
271     CopyRestoreDesc(newNode->restores,arestores);
272     *taskID = newNode->taskID;
273
274     /* should log the intent */
275
276     /* create the status node */
277     statusPtr = createStatusNode();
278     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
279
280     lock_Status();
281     statusPtr->taskId     = newNode->taskID;
282     statusPtr->flags     &= ~STARTING;                     /* ok to examine */
283     statusPtr->lastPolled = time(0);
284     strncpy(statusPtr->taskName, "Restore", sizeof(statusPtr->taskName));
285     unlock_Status();
286
287     newNode->statusNodePtr = statusPtr;
288
289     /* create the LWP to do the real work behind the scenes */
290 #ifdef AFS_PTHREAD_ENV
291     code = pthread_attr_init(&tattr);
292     if (code) ERROR_EXIT(code);
293
294     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
295     if (code) ERROR_EXIT(code);
296
297     AFS_SIGSET_CLEAR();
298     code = pthread_create(&pid, &tattr, Restorer, newNode);
299     AFS_SIGSET_RESTORE();
300 #else
301     code = LWP_CreateProcess(Restorer, 65368, 1,newNode ,"restorer process", &pid);
302 #endif
303
304 error_exit:
305     if ( code )
306     {
307         if (statusPtr) deleteStatusNode(statusPtr);
308         FreeNode(newNode->taskID);                 /*  failed to create LWP to do the dump. */
309     }
310
311     return(code);
312 }
313
314 STC_ReadLabel(acid, label, taskId)
315      struct rx_call *acid;
316      struct tc_tapeLabel *label;
317      afs_uint32 *taskId;
318 {
319     afs_int32 code;
320
321     extern int ReadLabel();
322    
323 #ifdef xbsa
324     if (CONF_XBSA) return(TC_BADTASK);    /* ReadLabel does not apply if XBSA */
325 #endif
326
327     if ( callPermitted(acid) == 0 )
328         return(TC_NOTPERMITTED);
329
330     code = ReadLabel(label); /* Synchronous */
331     return code;
332 }
333
334 /* STC_RestoreDb
335  *      restore the backup database from tape
336  */
337
338 STC_RestoreDb(rxCall, taskId)
339      struct rx_call *rxCall;
340      afs_uint32 *taskId;
341 {
342 #ifdef AFS_PTHREAD_ENV
343     pthread_t pid;
344     pthread_attr_t tattr;
345     AFS_SIGSET_DECL;
346 #else
347     PROCESS pid;
348 #endif
349     statusP statusPtr;
350     afs_int32 code = 0;
351
352     extern afs_int32 restoreDbFromTape();
353     extern statusP createStatusNode();
354     extern afs_int32 allocTaskId();
355
356 #ifdef xbsa
357     if (CONF_XBSA) return(TC_BADTASK);    /* LabelTape does not apply if XBSA */
358 #endif
359
360     if ( callPermitted(rxCall) == 0 )
361         return(TC_NOTPERMITTED);
362
363     *taskId = allocTaskId();
364
365     /* create the status node */
366     statusPtr = createStatusNode();
367     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
368
369     lock_Status();
370     statusPtr->taskId     = *taskId;
371     statusPtr->flags     &= ~STARTING;                     /* ok to examine */
372     statusPtr->lastPolled = time(0);
373     strncpy(statusPtr->taskName, "RestoreDb", sizeof(statusPtr->taskName));
374     unlock_Status();
375
376 #ifdef AFS_PTHREAD_ENV
377     code = pthread_attr_init(&tattr);
378     if (code) ERROR_EXIT(code);
379
380     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
381     if (code) ERROR_EXIT(code);
382
383     AFS_SIGSET_CLEAR();
384     code = pthread_create(&pid, &tattr, restoreDbFromTape, (void *)*taskId);
385     AFS_SIGSET_RESTORE();
386 #else
387     code = LWP_CreateProcess(restoreDbFromTape, 32768, 1, *taskId, "Db restore", &pid);
388 #endif
389
390 error_exit:
391     if ( code )
392     {
393         if (statusPtr) deleteStatusNode(statusPtr);
394     }
395
396     return(code);
397 }
398
399 /* STC_SaveDb
400  *      restore the backup database from tape
401  */
402
403 STC_SaveDb(rxCall, archiveTime, taskId)
404      struct rx_call *rxCall;
405      Date   archiveTime;
406      afs_uint32 *taskId;
407 {
408 #ifdef AFS_PTHREAD_ENV
409     pthread_t pid;
410     pthread_attr_t tattr;
411     AFS_SIGSET_DECL;
412 #else
413     PROCESS pid;
414 #endif
415     statusP statusPtr;
416     afs_int32 code = 0;
417     struct saveDbIf *ptr;
418
419     extern afs_int32 saveDbToTape();
420     extern statusP createStatusNode();
421     extern afs_int32 allocTaskId();
422
423 #ifdef xbsa
424     if (CONF_XBSA) return(TC_BADTASK);    /* LabelTape does not apply if XBSA */
425 #endif
426
427     if ( callPermitted(rxCall) == 0 )
428         return(TC_NOTPERMITTED);
429
430     *taskId = allocTaskId();
431
432     ptr = (struct saveDbIf *) malloc(sizeof(struct saveDbIf));
433     if (!ptr) ERROR_EXIT(TC_NOMEMORY);
434     ptr->archiveTime = archiveTime;
435     ptr->taskId      = *taskId;
436
437     /* create the status node */
438     statusPtr = createStatusNode();
439     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
440
441     lock_Status();
442     statusPtr->taskId     = *taskId;
443     statusPtr->lastPolled = time(0);
444     statusPtr->flags     &= ~STARTING;                     /* ok to examine */
445     strncpy(statusPtr->taskName, "SaveDb", sizeof(statusPtr->taskName));
446     unlock_Status();
447
448     ptr->statusPtr = statusPtr;
449
450 #ifdef AFS_PTHREAD_ENV
451     code = pthread_attr_init(&tattr);
452     if (code) ERROR_EXIT(code);
453
454     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
455     if (code) ERROR_EXIT(code);
456
457     AFS_SIGSET_CLEAR();
458     code = pthread_create(&pid, &tattr, saveDbToTape, ptr);
459     AFS_SIGSET_RESTORE();
460 #else
461     code = LWP_CreateProcess(saveDbToTape, 32768, 1, ptr ,"Db save", &pid);
462 #endif
463
464 error_exit:
465     if ( code )
466     {
467         if (statusPtr) deleteStatusNode(statusPtr);
468         if (ptr) free(ptr);
469     }
470
471     return(code);
472 }
473         
474
475 /* STC_ScanDumps
476  *      read a dump (maybe more than one tape), and print out a summary
477  *      of its contents. If the flag is set, add to the database.
478  * entry:
479  *      addDbFlag - if set, the information will be added to the database
480  */
481
482 STC_ScanDumps(acid, addDbFlag, taskId)
483      struct rx_call *acid;
484      afs_int32 addDbFlag;
485      afs_uint32 *taskId;
486 {
487 #ifdef AFS_PTHREAD_ENV
488     pthread_t pid;
489     pthread_attr_t tattr;
490     AFS_SIGSET_DECL;
491 #else
492     PROCESS pid;
493 #endif
494     struct scanTapeIf *ptr;
495     statusP statusPtr;
496     afs_int32 code = 0;
497
498     extern afs_int32 ScanDumps();
499     extern afs_int32 allocTaskId();
500     extern statusP createStatusNode();
501
502 #ifdef xbsa
503     if (CONF_XBSA) return(TC_BADTASK);    /* ScanDumps does not apply if XBSA */
504 #endif
505
506     if ( callPermitted(acid) == 0 )
507         return(TC_NOTPERMITTED);
508
509     *taskId = allocTaskId();
510
511     ptr = (struct scanTapeIf *) malloc(sizeof(*ptr));
512     if (!ptr) ERROR_EXIT(TC_NOMEMORY);
513     ptr->addDbFlag = addDbFlag;
514     ptr->taskId = *taskId;
515
516     /* create the status node */
517     statusPtr = createStatusNode();
518     if ( !statusPtr ) ERROR_EXIT(TC_INTERNALERROR);
519
520     lock_Status();
521     statusPtr->taskId     = *taskId;
522     statusPtr->lastPolled = time(0);
523     statusPtr->flags     &= ~STARTING;                     /* ok to examine */
524     strncpy(statusPtr->taskName, "Scantape", sizeof(statusPtr->taskName));
525     unlock_Status();
526
527 #ifdef AFS_PTHREAD_ENV
528     code = pthread_attr_init(&tattr);
529     if (code) ERROR_EXIT(code);
530
531     code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
532     if (code) ERROR_EXIT(code);
533
534     AFS_SIGSET_CLEAR();
535     code = pthread_create(&pid, &tattr, ScanDumps, ptr);
536     AFS_SIGSET_RESTORE();
537 #else
538     code = LWP_CreateProcess(ScanDumps,32768, 1, ptr, "scandump process",&pid);
539 #endif
540
541 error_exit:
542     if ( code )
543     {
544         if (statusPtr) deleteStatusNode(statusPtr);
545         if (ptr) free(ptr);
546     }
547
548     return code;
549 }
550
551 /* STC_TCInfo
552  *      return information about the tape coordinator. Currently this
553  *      is just the version number of the interface
554  */
555
556 STC_TCInfo(acid, tciptr)
557      struct rx_call *acid;
558      struct tc_tcInfo *tciptr;
559 {
560     if ( callPermitted(acid) == 0 )
561         return(TC_NOTPERMITTED);
562
563     tciptr->tcVersion = CUR_BUTC_VERSION;
564     return(0);
565 }
566
567 /* STC_DeleteDump
568  */
569 STC_DeleteDump(acid, dumpID, taskId)
570    struct rx_call *acid;
571    afs_uint32 dumpID;
572    afs_uint32 *taskId;
573 {
574    struct deleteDumpIf *ptr=0;
575    statusP statusPtr=0;
576    afs_int32 code = TC_BADTASK;   /* If not compiled -Dxbsa then fail */
577 #ifdef AFS_PTHREAD_ENV
578     pthread_t pid;
579     pthread_attr_t tattr;
580     AFS_SIGSET_DECL;
581 #else
582     PROCESS pid;
583 #endif
584     extern afs_int32 DeleteDump();
585     extern statusP createStatusNode();
586     extern afs_int32 allocTaskId();
587
588    *taskId = 0;
589    if (!CONF_XBSA) return(TC_BADTASK);   /* Only do if butc is started as XBSA */
590
591 #ifdef xbsa
592    code = 0;
593    if ( callPermitted(acid) == 0 )
594       return(TC_NOTPERMITTED);
595
596    ptr = (struct deleteDumpIf *) malloc(sizeof(*ptr));
597    if (!ptr) ERROR_EXIT(TC_NOMEMORY);
598
599    *taskId = allocTaskId();
600    ptr->dumpID = dumpID;
601    ptr->taskId = *taskId;
602
603    statusPtr = createStatusNode();
604    if (!statusPtr) ERROR_EXIT(TC_INTERNALERROR);
605
606    lock_Status();
607    statusPtr->taskId     = *taskId;
608    statusPtr->lastPolled = time(0);
609    statusPtr->flags     &= ~STARTING;
610    strncpy(statusPtr->taskName, "DeleteDump", sizeof(statusPtr->taskName));
611    unlock_Status();
612
613 #ifdef AFS_PTHREAD_ENV
614    code = pthread_attr_init(&tattr);
615    if (code) ERROR_EXIT(code);
616
617    code = pthread_attr_setdetachstate(&tattr, PTHREAD_CREATE_DETACHED);
618    if (code) ERROR_EXIT(code);
619
620    AFS_SIGSET_CLEAR();
621    code = pthread_create(&pid, &tattr, DeleteDump, ptr);
622    AFS_SIGSET_RESTORE();
623 #else
624    code = LWP_CreateProcess(DeleteDump, 32768, 1, ptr, "deletedump process", &pid);
625 #endif
626
627 error_exit:
628    if (code) {
629       if (statusPtr) deleteStatusNode(statusPtr);
630       if (ptr) free(ptr);
631    }
632 #endif /* xbsa */
633
634    return(code);
635 }
636
637 /* -----------------------------
638  * misc. routines
639  * -----------------------------
640  */
641
642 static
643 CopyDumpDesc(toDump, fromDump)
644      struct tc_dumpDesc *toDump;
645      tc_dumpArray *fromDump;
646 {
647     struct tc_dumpDesc *toPtr, *fromPtr;
648     int i;
649
650     toPtr   = toDump;
651     fromPtr = fromDump->tc_dumpArray_val;
652     for(i = 0 ; i < fromDump->tc_dumpArray_len; i++)
653     {
654         toPtr->vid       = fromPtr->vid;
655         toPtr->vtype     = fromPtr->vtype;
656         toPtr->partition = fromPtr->partition;
657         toPtr->date      = fromPtr->date;
658         toPtr->cloneDate = fromPtr->cloneDate;
659         toPtr->hostAddr  = fromPtr->hostAddr;
660         strcpy(toPtr->name,fromPtr->name);
661         fromPtr++;
662         toPtr++;
663     }
664     return 0;
665 }
666
667
668 static CopyRestoreDesc(toRestore, fromRestore)
669 struct tc_restoreDesc *toRestore;
670 tc_restoreArray *fromRestore;
671 {
672     struct tc_restoreDesc *toPtr, *fromPtr;
673     int i;
674     
675     toPtr = toRestore ;
676     fromPtr = fromRestore->tc_restoreArray_val;
677     for(i = 0 ; i < fromRestore->tc_restoreArray_len ; i++){
678         toPtr->flags         = fromPtr->flags;
679         toPtr->position      = fromPtr->position;
680         strcpy(toPtr->tapeName,fromPtr->tapeName);
681         toPtr->dbDumpId      = fromPtr->dbDumpId;
682         toPtr->initialDumpId = fromPtr->initialDumpId;
683         toPtr->origVid       = fromPtr->origVid;
684         toPtr->vid           = fromPtr->vid;
685         toPtr->partition     = fromPtr->partition;
686         toPtr->dumpLevel     = fromPtr->dumpLevel;
687         toPtr->hostAddr      = fromPtr->hostAddr;
688         strcpy(toPtr->newName,fromPtr->newName);
689         strcpy(toPtr->oldName, fromPtr->oldName);
690         fromPtr++;
691         toPtr++;
692
693     }
694     return 0;
695 }
696
697 static CopyTapeSetDesc(toPtr,fromPtr)
698 struct tc_tapeSet *toPtr,*fromPtr;
699 {
700     
701     toPtr->id = fromPtr->id;
702     toPtr->maxTapes = fromPtr->maxTapes;
703     toPtr->a = fromPtr->a;
704     toPtr->b = fromPtr->b;
705     strcpy(toPtr->tapeServer,fromPtr->tapeServer);
706     strcpy(toPtr->format,fromPtr->format);
707
708     toPtr->expDate = fromPtr->expDate;
709     toPtr->expType = fromPtr->expType;
710     return 0;
711 }