]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/bls.c
Update doc
[bacula/bacula] / bacula / src / stored / bls.c
1 /*
2  *
3  *  Dumb program to do an "ls" of a Bacula 1.0 mortal file.
4  *
5  *   Version $Id$
6  */
7 /*
8    Copyright (C) 2000-2004 Kern Sibbald and John Walker
9
10    This program is free software; you can redistribute it and/or
11    modify it under the terms of the GNU General Public License as
12    published by the Free Software Foundation; either version 2 of
13    the License, or (at your option) any later version.
14
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18    General Public License for more details.
19
20    You should have received a copy of the GNU General Public
21    License along with this program; if not, write to the Free
22    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
23    MA 02111-1307, USA.
24
25  */
26
27 #include "bacula.h"
28 #include "stored.h"
29 #include "findlib/find.h"
30
31 #if defined(HAVE_CYGWIN) || defined(HAVE_WIN32)
32 int win32_client = 1;
33 #else
34 int win32_client = 0;
35 #endif
36
37 static void do_blocks(char *infname);
38 static void do_jobs(char *infname);
39 static void do_ls(char *fname);
40 static void do_close(JCR *jcr);
41 static void get_session_record(DEVICE *dev, DEV_RECORD *rec, SESSION_LABEL *sessrec);
42 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec);
43
44 static DEVICE *dev;
45 static int dump_label = FALSE;
46 static int list_blocks = FALSE;
47 static int list_jobs = FALSE;
48 static DEV_RECORD *rec;
49 static DEV_BLOCK *block;
50 static JCR *jcr;
51 static SESSION_LABEL sessrec;
52 static uint32_t num_files = 0;
53 static ATTR *attr;
54
55 #define CONFIG_FILE "bacula-sd.conf"
56 char *configfile;
57 bool forge_on = false;
58
59
60 static FF_PKT ff;
61
62 static BSR *bsr = NULL;
63
64 static void usage()
65 {
66    fprintf(stderr,
67 "\nVersion: " VERSION " (" BDATE ")\n\n"
68 "Usage: bls [-d debug_level] <physical-device-name>\n"
69 "       -b <file>       specify a bootstrap file\n"
70 "       -c <file>       specify a config file\n"
71 "       -d <level>      specify debug level\n"
72 "       -e <file>       exclude list\n"
73 "       -i <file>       include list\n"
74 "       -j              list jobs\n"
75 "       -k              list blocks\n"
76 "    (no j or k option) list saved files\n"
77 "       -L              dump label\n"
78 "       -p              proceed inspite of errors\n"
79 "       -v              be verbose\n"
80 "       -V              specify Volume names (separated by |)\n"
81 "       -?              print this message\n\n");
82    exit(1);
83 }
84
85
86 int main (int argc, char *argv[])
87 {
88    int i, ch;
89    FILE *fd;
90    char line[1000];
91    char *VolumeName= NULL;
92    char *bsrName = NULL;
93    bool ignore_label_errors = false;
94
95    working_directory = "/tmp";
96    my_name_is(argc, argv, "bls");
97    init_msg(NULL, NULL);              /* initialize message handler */
98
99    memset(&ff, 0, sizeof(ff));
100    init_include_exclude_files(&ff);
101
102    while ((ch = getopt(argc, argv, "b:c:d:e:i:jkLpvV:?")) != -1) {
103       switch (ch) {
104       case 'b':
105          bsrName = optarg;
106          break;
107
108       case 'c':                    /* specify config file */
109          if (configfile != NULL) {
110             free(configfile);
111          }
112          configfile = bstrdup(optarg);
113          break;
114
115       case 'd':                    /* debug level */
116          debug_level = atoi(optarg);
117          if (debug_level <= 0)
118             debug_level = 1; 
119          break;
120
121       case 'e':                    /* exclude list */
122          if ((fd = fopen(optarg, "r")) == NULL) {
123             Pmsg2(0, _("Could not open exclude file: %s, ERR=%s\n"),
124                optarg, strerror(errno));
125             exit(1);
126          }
127          while (fgets(line, sizeof(line), fd) != NULL) {
128             strip_trailing_junk(line);
129             Dmsg1(100, "add_exclude %s\n", line);
130             add_fname_to_exclude_list(&ff, line);
131          }
132          fclose(fd);
133          break;
134
135       case 'i':                    /* include list */
136          if ((fd = fopen(optarg, "r")) == NULL) {
137             Pmsg2(0, "Could not open include file: %s, ERR=%s\n",
138                optarg, strerror(errno));
139             exit(1);
140          }
141          while (fgets(line, sizeof(line), fd) != NULL) {
142             strip_trailing_junk(line);
143             Dmsg1(100, "add_include %s\n", line);
144             add_fname_to_include_list(&ff, 0, line);
145          }
146          fclose(fd);
147          break;
148
149       case 'j':
150          list_jobs = TRUE;
151          break;
152
153       case 'k':
154          list_blocks = TRUE;
155          break;
156
157       case 'L':
158          dump_label = TRUE;
159          break;
160
161       case 'p':
162          ignore_label_errors = true;
163          forge_on = true;
164          break;
165
166       case 'v':
167          verbose++;
168          break;
169
170       case 'V':                    /* Volume name */
171          VolumeName = optarg;
172          break;
173
174       case '?':
175       default:
176          usage();
177
178       } /* end switch */
179    } /* end while */
180    argc -= optind;
181    argv += optind;
182
183    if (!argc) {
184       Pmsg0(0, _("No archive name specified\n"));
185       usage();
186    }
187
188    if (configfile == NULL) {
189       configfile = bstrdup(CONFIG_FILE);
190    }
191
192    parse_config(configfile);
193
194    if (ff.included_files_list == NULL) {
195       add_fname_to_include_list(&ff, 0, "/");
196    }
197
198    for (i=0; i < argc; i++) {
199       if (bsrName) {
200          bsr = parse_bsr(NULL, bsrName);
201       }
202       jcr = setup_jcr("bls", argv[i], bsr, VolumeName);
203       jcr->ignore_label_errors = ignore_label_errors;
204       dev = setup_to_access_device(jcr, 1);   /* acquire for read */
205       if (!dev) {
206          exit(1);
207       }
208       rec = new_record();
209       block = new_block(dev);
210       attr = new_attr();
211       /*
212        * Assume that we have already read the volume label.
213        * If on second or subsequent volume, adjust buffer pointer 
214        */
215       if (dev->VolHdr.PrevVolName[0] != 0) { /* second volume */
216          Pmsg1(0, "\n\
217 Warning, this Volume is a continuation of Volume %s\n",
218                 dev->VolHdr.PrevVolName);
219       }
220
221       if (list_blocks) {
222          do_blocks(argv[i]);
223       } else if (list_jobs) {
224          do_jobs(argv[i]);
225       } else {
226          do_ls(argv[i]);
227       }
228       do_close(jcr);
229    }
230    if (bsr) {
231       free_bsr(bsr);
232    }
233    return 0;
234 }
235
236
237 static void do_close(JCR *jcr)
238 {
239    release_device(jcr);
240    free_attr(attr);
241    term_dev(dev);
242    free_record(rec);
243    free_block(block);
244    free_jcr(jcr);
245 }
246
247
248 /* List just block information */
249 static void do_blocks(char *infname)
250 {
251    if (verbose) {
252       dump_volume_label(dev);
253       rec = new_record();
254    }
255    for ( ;; ) {
256       if (!read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK)) {
257          Dmsg1(100, "!read_block(): ERR=%s\n", strerror_dev(dev));
258          if (dev->state & ST_EOT) {
259             if (!mount_next_read_volume(jcr, dev, block)) {
260                Jmsg(jcr, M_INFO, 0, _("Got EOM at file %u on device %s, Volume \"%s\"\n"), 
261                   dev->file, dev_name(dev), jcr->VolumeName);
262                break;
263             }
264             /* Read and discard Volume label */
265             DEV_RECORD *record;
266             record = new_record();
267             read_block_from_device(jcr, dev, block, NO_BLOCK_NUMBER_CHECK);
268             read_record_from_block(block, record);
269             get_session_record(dev, record, &sessrec);
270             free_record(record);
271             Jmsg(jcr, M_INFO, 0, _("Mounted Volume \"%s\".\n"), jcr->VolumeName);
272             
273          } else if (dev->state & ST_EOF) {
274             Jmsg(jcr, M_INFO, 0, _("Got EOF at file %u on device %s, Volume \"%s\"\n"), 
275                dev->file, dev_name(dev), jcr->VolumeName);
276             Dmsg0(20, "read_record got eof. try again\n");
277             continue;
278          } else if (dev->state & ST_SHORT) {
279             Jmsg(jcr, M_INFO, 0, "%s", dev->errmsg);
280             continue;
281          } else {
282             /* I/O error */
283             display_tape_error_status(jcr, dev);
284             break;
285          }
286       }
287       if (!match_bsr_block(bsr, block)) {
288          Dmsg5(100, "reject Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
289             block->BlockNumber, block->block_len, block->BlockVer,
290             block->VolSessionId, block->VolSessionTime);
291          continue;
292       }
293       Dmsg5(100, "Blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
294         block->BlockNumber, block->block_len, block->BlockVer,
295         block->VolSessionId, block->VolSessionTime);
296       if (verbose == 1) {
297          read_record_from_block(block, rec);
298          Pmsg7(-1, "Block: %u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n",
299               block->BlockNumber, block->block_len,
300               FI_to_ascii(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
301               stream_to_ascii(rec->Stream, rec->FileIndex), rec->data_len);
302          rec->remainder = 0;
303       } else if (verbose > 1) {
304          dump_block(block, "");
305       } else {
306          printf("Block: %d size=%d\n", block->BlockNumber, block->block_len);
307       }
308
309    }
310    return;
311 }
312
313 /*
314  * We are only looking for labels or in particular Job Session records
315  */
316 static int jobs_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
317 {
318    if (rec->FileIndex < 0) {
319       dump_label_record(dev, rec, verbose);
320    }
321    rec->remainder = 0;
322    return 1;
323 }
324
325 /* Do list job records */
326 static void do_jobs(char *infname)
327 {
328    read_records(jcr, dev, jobs_cb, mount_next_read_volume);
329 }
330
331 /* Do an ls type listing of an archive */
332 static void do_ls(char *infname)
333 {
334    if (dump_label) {
335       dump_volume_label(dev);
336       return;
337    }
338    read_records(jcr, dev, record_cb, mount_next_read_volume);
339    printf("%u files found.\n", num_files);
340 }
341
342 /*
343  * Called here for each record from read_records()
344  */
345 static int record_cb(JCR *jcr, DEVICE *dev, DEV_BLOCK *block, DEV_RECORD *rec)
346 {
347    if (rec->FileIndex < 0) {
348       get_session_record(dev, rec, &sessrec);
349       return 1;
350    }
351    /* File Attributes stream */
352    if (rec->Stream == STREAM_UNIX_ATTRIBUTES || 
353        rec->Stream == STREAM_UNIX_ATTRIBUTES_EX) {
354
355       if (!unpack_attributes_record(jcr, rec->Stream, rec->data, attr)) {
356          Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
357       }
358
359       if (attr->file_index != rec->FileIndex) {
360          Emsg2(M_ERROR_TERM, 0, _("Record header file index %ld not equal record index %ld\n"),
361             rec->FileIndex, attr->file_index);
362       }
363
364       attr->data_stream = decode_stat(attr->attr, &attr->statp, &attr->LinkFI);
365       build_attr_output_fnames(jcr, attr);
366
367       if (file_is_included(&ff, attr->fname) && !file_is_excluded(&ff, attr->fname)) {
368          print_ls_output(jcr, attr);
369          num_files++;
370       }
371    }
372    return 1;
373 }
374
375
376 static void get_session_record(DEVICE *dev, DEV_RECORD *rec, SESSION_LABEL *sessrec)
377 {
378    char *rtype;
379    memset(sessrec, 0, sizeof(sessrec));
380    switch (rec->FileIndex) {
381    case PRE_LABEL:
382       rtype = "Fresh Volume Label";   
383       break;
384    case VOL_LABEL:
385       rtype = "Volume Label";
386       unser_volume_label(dev, rec);
387       break;
388    case SOS_LABEL:
389       rtype = "Begin Session";
390       unser_session_label(sessrec, rec);
391       break;
392    case EOS_LABEL:
393       rtype = "End Session";
394       break;
395    case EOM_LABEL:
396       rtype = "End of Medium";
397       break;
398    default:
399       rtype = "Unknown";
400       break;
401    }
402    Dmsg5(10, "%s Record: VolSessionId=%d VolSessionTime=%d JobId=%d DataLen=%d\n",
403          rtype, rec->VolSessionId, rec->VolSessionTime, rec->Stream, rec->data_len);
404 }
405
406
407 /* Dummies to replace askdir.c */
408 int     dir_get_volume_info(JCR *jcr, enum get_vol_info_rw  writing) { return 1;}
409 int     dir_find_next_appendable_volume(JCR *jcr) { return 1;}
410 int     dir_update_volume_info(JCR *jcr, DEVICE *dev, int relabel) { return 1; }
411 int     dir_create_jobmedia_record(JCR *jcr) { return 1; }
412 int     dir_ask_sysop_to_create_appendable_volume(JCR *jcr, DEVICE *dev) { return 1; }
413 int     dir_update_file_attributes(JCR *jcr, DEV_RECORD *rec) { return 1;}
414 int     dir_send_job_status(JCR *jcr) {return 1;}
415
416
417 int dir_ask_sysop_to_mount_volume(JCR *jcr, DEVICE *dev)
418 {
419    fprintf(stderr, "Mount Volume \"%s\" on device %s and press return when ready: ",
420       jcr->VolumeName, dev_name(dev));
421    getchar();   
422    return 1;
423 }