]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/record.c
kes Add back code to open tape device nonblocking, but if rewind fails
[bacula/bacula] / bacula / src / stored / record.c
1 /*
2  *
3  *   record.c -- tape record handling functions
4  *
5  *              Kern Sibbald, April MMI
6  *                added BB02 format October MMII
7  *
8  *   Version $Id$
9  *
10  */
11 /*
12    Copyright (C) 2001-2005 Kern Sibbald
13
14    This program is free software; you can redistribute it and/or
15    modify it under the terms of the GNU General Public License
16    version 2 as amended with additional clauses defined in the
17    file LICENSE in the main source directory.
18
19    This program is distributed in the hope that it will be useful,
20    but WITHOUT ANY WARRANTY; without even the implied warranty of
21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
22    the file LICENSE for additional details.
23
24  */
25
26
27 #include "bacula.h"
28 #include "stored.h"
29
30 /*
31  * Convert a FileIndex into a printable
32  *   ASCII string.  Not reentrant.
33  * If the FileIndex is negative, it flags the
34  *   record as a Label, otherwise it is simply
35  *   the FileIndex of the current file.
36  */
37 const char *FI_to_ascii(char *buf, int fi)
38 {
39    if (fi >= 0) {
40       sprintf(buf, "%d", fi);
41       return buf;
42    }
43    switch (fi) {
44    case PRE_LABEL:
45       return "PRE_LABEL";
46    case VOL_LABEL:
47       return "VOL_LABEL";
48    case EOM_LABEL:
49       return "EOM_LABEL";
50    case SOS_LABEL:
51       return "SOS_LABEL";
52    case EOS_LABEL:
53       return "EOS_LABEL";
54    case EOT_LABEL:
55       return "EOT_LABEL";
56       break;
57    default:
58      sprintf(buf, _("unknown: %d"), fi);
59      return buf;
60    }
61 }
62
63
64 /*
65  * Convert a Stream ID into a printable
66  * ASCII string.  Not reentrant.
67
68  * A negative stream number represents
69  *   stream data that is continued from a
70  *   record in the previous block.
71  * If the FileIndex is negative, we are
72  *   dealing with a Label, hence the
73  *   stream is the JobId.
74  */
75 const char *stream_to_ascii(char *buf, int stream, int fi)
76 {
77     if (fi < 0) {
78        sprintf(buf, "%d", stream);
79        return buf;
80     }
81     switch (stream) {
82     case STREAM_UNIX_ATTRIBUTES:
83        return "UATTR";
84     case STREAM_FILE_DATA:
85        return "DATA";
86     case STREAM_WIN32_DATA:
87        return "WIN32-DATA";
88     case STREAM_WIN32_GZIP_DATA:
89        return "WIN32-GZIP";
90     case STREAM_MD5_DIGEST:
91        return "MD5";
92     case STREAM_SHA1_DIGEST:
93        return "SHA1";
94     case STREAM_GZIP_DATA:
95        return "GZIP";
96     case STREAM_UNIX_ATTRIBUTES_EX:
97        return "UNIX-ATTR-EX";
98     case STREAM_SPARSE_DATA:
99        return "SPARSE-DATA";
100     case STREAM_SPARSE_GZIP_DATA:
101        return "SPARSE-GZIP";
102     case STREAM_PROGRAM_NAMES:
103        return "PROG-NAMES";
104     case STREAM_PROGRAM_DATA:
105        return "PROG-DATA";
106     case STREAM_MACOS_FORK_DATA:
107        return "MACOS-RSRC";
108     case STREAM_HFSPLUS_ATTRIBUTES:
109        return "HFSPLUS-ATTR";
110     case STREAM_SHA256_DIGEST:
111        return "SHA256";
112     case STREAM_SHA512_DIGEST:
113        return "SHA512";
114     case STREAM_SIGNED_DIGEST:
115        return "SIGNED-DIGEST";
116     case STREAM_ENCRYPTED_SESSION_DATA:
117        return "ENCRYPTED-SESSION-DATA";
118     case STREAM_ENCRYPTED_FILE_DATA:
119        return "ENCRYPTED-FILE";
120     case STREAM_ENCRYPTED_FILE_GZIP_DATA:
121        return "ENCRYPTED-GZIP";
122     case STREAM_ENCRYPTED_WIN32_DATA:
123        return "ENCRYPTED-WIN32-DATA";
124     case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
125        return "ENCRYPTED-WIN32-GZIP";
126     case STREAM_ENCRYPTED_MACOS_FORK_DATA:
127        return "ENCRYPTED-MACOS-RSRC";
128     case -STREAM_UNIX_ATTRIBUTES:
129        return "contUATTR";
130     case -STREAM_FILE_DATA:
131        return "contDATA";
132     case -STREAM_WIN32_DATA:
133        return "contWIN32-DATA";
134     case -STREAM_WIN32_GZIP_DATA:
135        return "contWIN32-GZIP";
136     case -STREAM_MD5_DIGEST:
137        return "contMD5";
138     case -STREAM_SHA1_DIGEST:
139        return "contSHA1";
140     case -STREAM_GZIP_DATA:
141        return "contGZIP";
142     case -STREAM_UNIX_ATTRIBUTES_EX:
143        return "contUNIX-ATTR-EX";
144     case -STREAM_SPARSE_DATA:
145        return "contSPARSE-DATA";
146     case -STREAM_SPARSE_GZIP_DATA:
147        return "contSPARSE-GZIP";
148     case -STREAM_PROGRAM_NAMES:
149        return "contPROG-NAMES";
150     case -STREAM_PROGRAM_DATA:
151        return "contPROG-DATA";
152     case -STREAM_MACOS_FORK_DATA:
153        return "contMACOS-RSRC";
154     case -STREAM_HFSPLUS_ATTRIBUTES:
155        return "contHFSPLUS-ATTR";
156     case -STREAM_SHA256_DIGEST:
157        return "contSHA256";
158     case -STREAM_SHA512_DIGEST:
159        return "contSHA512";
160     case -STREAM_SIGNED_DIGEST:
161        return "contSIGNED-DIGEST";
162     case -STREAM_ENCRYPTED_SESSION_DATA:
163        return "contENCRYPTED-SESSION-DATA";
164     case -STREAM_ENCRYPTED_FILE_DATA:
165        return "contENCRYPTED-FILE";
166     case -STREAM_ENCRYPTED_FILE_GZIP_DATA:
167        return "contENCRYPTED-GZIP";
168     case -STREAM_ENCRYPTED_WIN32_DATA:
169        return "contENCRYPTED-WIN32-DATA";
170     case -STREAM_ENCRYPTED_WIN32_GZIP_DATA:
171        return "contENCRYPTED-WIN32-GZIP";
172     case -STREAM_ENCRYPTED_MACOS_FORK_DATA:
173        return "contENCRYPTED-MACOS-RSRC";
174     default:
175        sprintf(buf, "%d", stream);
176        return buf;
177     }
178 }
179
180 /*
181  * Return a new record entity
182  */
183 DEV_RECORD *new_record(void)
184 {
185    DEV_RECORD *rec;
186
187    rec = (DEV_RECORD *)get_memory(sizeof(DEV_RECORD));
188    memset(rec, 0, sizeof(DEV_RECORD));
189    rec->data = get_pool_memory(PM_MESSAGE);
190    return rec;
191 }
192
193 void empty_record(DEV_RECORD *rec)
194 {
195    rec->File = rec->Block = 0;
196    rec->VolSessionId = rec->VolSessionTime = 0;
197    rec->FileIndex = rec->Stream = 0;
198    rec->data_len = rec->remainder = 0;
199    rec->state &= ~(REC_PARTIAL_RECORD|REC_BLOCK_EMPTY|REC_NO_MATCH|REC_CONTINUATION);
200 }
201
202 /*
203  * Free the record entity
204  *
205  */
206 void free_record(DEV_RECORD *rec)
207 {
208    Dmsg0(950, "Enter free_record.\n");
209    if (rec->data) {
210       free_pool_memory(rec->data);
211    }
212    Dmsg0(950, "Data buf is freed.\n");
213    free_pool_memory((POOLMEM *)rec);
214    Dmsg0(950, "Leave free_record.\n");
215 }
216
217
218 /*
219  * Write a Record to the block
220  *
221  *  Returns: false on failure (none or partially written)
222  *           true  on success (all bytes written)
223  *
224  *  and remainder returned in packet.
225  *
226  *  We require enough room for the header, and we deal with
227  *  two special cases. 1. Only part of the record may have
228  *  been transferred the last time (when remainder is
229  *  non-zero), and 2. The remaining bytes to write may not
230  *  all fit into the block.
231  */
232 bool write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec)
233 {
234    ser_declare;
235    uint32_t remlen;
236    char buf1[100], buf2[100];
237
238    remlen = block->buf_len - block->binbuf;
239
240    ASSERT(block->binbuf == (uint32_t) (block->bufp - block->buf));
241    ASSERT(block->buf_len >= block->binbuf);
242
243    Dmsg6(890, "write_record_to_block() FI=%s SessId=%d Strm=%s len=%d\n"
244 "rem=%d remainder=%d\n",
245       FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
246       stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
247       remlen, rec->remainder);
248
249    /*
250     * If rec->remainder is non-zero, we have been called a
251     *  second (or subsequent) time to finish writing a record
252     *  that did not previously fit into the block.
253     */
254    if (rec->remainder == 0) {
255       /* Require enough room to write a full header */
256       if (remlen >= WRITE_RECHDR_LENGTH) {
257          ser_begin(block->bufp, WRITE_RECHDR_LENGTH);
258          if (BLOCK_VER == 1) {
259             ser_uint32(rec->VolSessionId);
260             ser_uint32(rec->VolSessionTime);
261          } else {
262             block->VolSessionId = rec->VolSessionId;
263             block->VolSessionTime = rec->VolSessionTime;
264          }
265          ser_int32(rec->FileIndex);
266          ser_int32(rec->Stream);
267          ser_uint32(rec->data_len);
268
269          block->bufp += WRITE_RECHDR_LENGTH;
270          block->binbuf += WRITE_RECHDR_LENGTH;
271          remlen -= WRITE_RECHDR_LENGTH;
272          rec->remainder = rec->data_len;
273          if (rec->FileIndex > 0) {
274             /* If data record, update what we have in this block */
275             if (block->FirstIndex == 0) {
276                block->FirstIndex = rec->FileIndex;
277             }
278             block->LastIndex = rec->FileIndex;
279          }
280       } else {
281          rec->remainder = rec->data_len + WRITE_RECHDR_LENGTH;
282          return false;
283       }
284    } else {
285       /*
286        * We are here to write unwritten bytes from a previous
287        * time. Presumably we have a new buffer (possibly
288        * containing a volume label), so the new header
289        * should be able to fit in the block -- otherwise we have
290        * an error.  Note, we have to continue splitting the
291        * data record if it is longer than the block.
292        *
293        * First, write the header, then write as much as
294        * possible of the data record.
295        *
296        * Every time we write a header and it is a continuation
297        * of a previous partially written record, we store the
298        * Stream as -Stream in the record header.
299        */
300       ser_begin(block->bufp, WRITE_RECHDR_LENGTH);
301       if (BLOCK_VER == 1) {
302          ser_uint32(rec->VolSessionId);
303          ser_uint32(rec->VolSessionTime);
304       } else {
305          block->VolSessionId = rec->VolSessionId;
306          block->VolSessionTime = rec->VolSessionTime;
307       }
308       ser_int32(rec->FileIndex);
309       if (rec->remainder > rec->data_len) {
310          ser_int32(rec->Stream);      /* normal full header */
311          ser_uint32(rec->data_len);
312          rec->remainder = rec->data_len; /* must still do data record */
313       } else {
314          ser_int32(-rec->Stream);     /* mark this as a continuation record */
315          ser_uint32(rec->remainder);  /* bytes to do */
316       }
317
318       /* Require enough room to write a full header */
319       ASSERT(remlen >= WRITE_RECHDR_LENGTH);
320
321       block->bufp += WRITE_RECHDR_LENGTH;
322       block->binbuf += WRITE_RECHDR_LENGTH;
323       remlen -= WRITE_RECHDR_LENGTH;
324       if (rec->FileIndex > 0) {
325          /* If data record, update what we have in this block */
326          if (block->FirstIndex == 0) {
327             block->FirstIndex = rec->FileIndex;
328          }
329          block->LastIndex = rec->FileIndex;
330       }
331    }
332    if (remlen == 0) {
333       return false;                   /* partial transfer */
334    }
335
336    /*
337     * Now deal with data record.
338     * Part of it may have already been transferred, and we
339     * may not have enough room to transfer the whole this time.
340     */
341    if (rec->remainder > 0) {
342       /* Write as much of data as possible */
343       if (remlen >= rec->remainder) {
344          memcpy(block->bufp, rec->data+rec->data_len-rec->remainder,
345                 rec->remainder);
346          block->bufp += rec->remainder;
347          block->binbuf += rec->remainder;
348       } else {
349          memcpy(block->bufp, rec->data+rec->data_len-rec->remainder,
350                 remlen);
351 #ifdef xxxxxSMCHECK
352          if (!sm_check_rtn(__FILE__, __LINE__, False)) {
353             /* We damaged a buffer */
354             Dmsg6(0, "Damaged block FI=%s SessId=%d Strm=%s len=%d\n"
355 "rem=%d remainder=%d\n",
356                FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
357                stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len,
358                remlen, rec->remainder);
359             Dmsg5(0, "Damaged block: bufp=%x binbuf=%d buf_len=%d rem=%d moved=%d\n",
360                block->bufp, block->binbuf, block->buf_len, block->buf_len-block->binbuf,
361                remlen);
362             Dmsg2(0, "Damaged block: buf=%x binbuffrombuf=%d \n",
363                block->buf, block->bufp-block->buf);
364
365                Emsg0(M_ABORT, 0, _("Damaged buffer\n"));
366          }
367 #endif
368
369          block->bufp += remlen;
370          block->binbuf += remlen;
371          rec->remainder -= remlen;
372          return false;                /* did partial transfer */
373       }
374    }
375    rec->remainder = 0;                /* did whole transfer */
376    return true;
377 }
378
379
380 /*
381  * Test if we can write whole record to the block
382  *
383  *  Returns: false on failure
384  *           true  on success (all bytes can be written)
385  */
386 bool can_write_record_to_block(DEV_BLOCK *block, DEV_RECORD *rec)
387 {
388    uint32_t remlen;
389
390    remlen = block->buf_len - block->binbuf;
391    if (rec->remainder == 0) {
392       if (remlen >= WRITE_RECHDR_LENGTH) {
393          remlen -= WRITE_RECHDR_LENGTH;
394          rec->remainder = rec->data_len;
395       } else {
396          return false;
397       }
398    } else {
399       return false;
400    }
401    if (rec->remainder > 0 && remlen < rec->remainder) {
402       return false;
403    }
404    return true;
405 }
406
407
408 /*
409  * Read a Record from the block
410  *  Returns: false if nothing read or if the continuation record does not match.
411  *                 In both of these cases, a block read must be done.
412  *           true  if at least the record header was read, this
413  *                 routine may have to be called again with a new
414  *                 block if the entire record was not read.
415  */
416 bool read_record_from_block(DEV_BLOCK *block, DEV_RECORD *rec)
417 {
418    ser_declare;
419    uint32_t remlen;
420    uint32_t VolSessionId;
421    uint32_t VolSessionTime;
422    int32_t  FileIndex;
423    int32_t  Stream;
424    uint32_t data_bytes;
425    uint32_t rhl;
426    char buf1[100], buf2[100];
427
428    remlen = block->binbuf;
429    rec->Block = block->BlockNumber;
430    rec->File = ((DEVICE *)block->dev)->file;
431
432    /* Clear state flags */
433    rec->state = 0;
434    if (block->dev->is_tape()) {
435       rec->state |= REC_ISTAPE;
436    }
437
438
439    /*
440     * Get the header. There is always a full header,
441     * otherwise we find it in the next block.
442     */
443    Dmsg3(450, "Block=%d Ver=%d size=%u\n", block->BlockNumber, block->BlockVer,
444          block->block_len);
445    if (block->BlockVer == 1) {
446       rhl = RECHDR1_LENGTH;
447    } else {
448       rhl = RECHDR2_LENGTH;
449    }
450    if (remlen >= rhl) {
451       Dmsg4(450, "Enter read_record_block: remlen=%d data_len=%d rem=%d blkver=%d\n",
452             remlen, rec->data_len, rec->remainder, block->BlockVer);
453
454       unser_begin(block->bufp, WRITE_RECHDR_LENGTH);
455       if (block->BlockVer == 1) {
456          unser_uint32(VolSessionId);
457          unser_uint32(VolSessionTime);
458       } else {
459          VolSessionId = block->VolSessionId;
460          VolSessionTime = block->VolSessionTime;
461       }
462       unser_int32(FileIndex);
463       unser_int32(Stream);
464       unser_uint32(data_bytes);
465
466       block->bufp += rhl;
467       block->binbuf -= rhl;
468       remlen -= rhl;
469
470       /* If we are looking for more (remainder!=0), we reject anything
471        *  where the VolSessionId and VolSessionTime don't agree
472        */
473       if (rec->remainder && (rec->VolSessionId != VolSessionId ||
474                              rec->VolSessionTime != VolSessionTime)) {
475          rec->state |= REC_NO_MATCH;
476          Dmsg0(450, "remainder and VolSession doesn't match\n");
477          return false;             /* This is from some other Session */
478       }
479
480       /* if Stream is negative, it means that this is a continuation
481        * of a previous partially written record.
482        */
483       if (Stream < 0) {               /* continuation record? */
484          Dmsg1(500, "Got negative Stream => continuation. remainder=%d\n",
485             rec->remainder);
486          rec->state |= REC_CONTINUATION;
487          if (!rec->remainder) {       /* if we didn't read previously */
488             rec->data_len = 0;        /* return data as if no continuation */
489          } else if (rec->Stream != -Stream) {
490             rec->state |= REC_NO_MATCH;
491             return false;             /* This is from some other Session */
492          }
493          rec->Stream = -Stream;       /* set correct Stream */
494       } else {                        /* Regular record */
495          rec->Stream = Stream;
496          rec->data_len = 0;           /* transfer to beginning of data */
497       }
498       rec->VolSessionId = VolSessionId;
499       rec->VolSessionTime = VolSessionTime;
500       rec->FileIndex = FileIndex;
501       if (FileIndex > 0) {
502          if (block->FirstIndex == 0) {
503             block->FirstIndex = FileIndex;
504          }
505          block->LastIndex = FileIndex;
506       }
507
508       Dmsg6(450, "rd_rec_blk() got FI=%s SessId=%d Strm=%s len=%u\n"
509                  "remlen=%d data_len=%d\n",
510          FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
511          stream_to_ascii(buf2, rec->Stream, rec->FileIndex), data_bytes, remlen,
512          rec->data_len);
513    } else {
514       /*
515        * No more records in this block because the number
516        * of remaining bytes are less than a record header
517        * length, so return empty handed, but indicate that
518        * he must read again. By returning, we allow the
519        * higher level routine to fetch the next block and
520        * then reread.
521        */
522       Dmsg0(450, "read_record_block: nothing\n");
523       rec->state |= (REC_NO_HEADER | REC_BLOCK_EMPTY);
524       empty_block(block);                      /* mark block empty */
525       return false;
526    }
527
528    ASSERT(data_bytes < MAX_BLOCK_LENGTH);       /* temp sanity check */
529
530    rec->data = check_pool_memory_size(rec->data, rec->data_len+data_bytes);
531
532    /*
533     * At this point, we have read the header, now we
534     * must transfer as much of the data record as
535     * possible taking into account: 1. A partial
536     * data record may have previously been transferred,
537     * 2. The current block may not contain the whole data
538     * record.
539     */
540    if (remlen >= data_bytes) {
541       /* Got whole record */
542       memcpy(rec->data+rec->data_len, block->bufp, data_bytes);
543       block->bufp += data_bytes;
544       block->binbuf -= data_bytes;
545       rec->data_len += data_bytes;
546    } else {
547       /* Partial record */
548       memcpy(rec->data+rec->data_len, block->bufp, remlen);
549       block->bufp += remlen;
550       block->binbuf -= remlen;
551       rec->data_len += remlen;
552       rec->remainder = 1;             /* partial record transferred */
553       Dmsg1(450, "read_record_block: partial xfered=%d\n", rec->data_len);
554       rec->state |= (REC_PARTIAL_RECORD | REC_BLOCK_EMPTY);
555       return 1;
556    }
557    rec->remainder = 0;
558    Dmsg4(450, "Rtn full rd_rec_blk FI=%s SessId=%d Strm=%s len=%d\n",
559       FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId,
560       stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
561    return true;                       /* transferred full record */
562 }