]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/fd_cmds.c
First cut SIGHUM + misc
[bacula/bacula] / bacula / src / dird / fd_cmds.c
1 /*
2  *
3  *   Bacula Director -- fd_cmds.c -- send commands to File daemon
4  *
5  *     Kern Sibbald, October MM
6  *
7  *    This routine is run as a separate thread.  There may be more
8  *    work to be done to make it totally reentrant!!!!
9  * 
10  *  Utility functions for sending info to File Daemon.
11  *   These functions are used by both backup and verify.
12  *   
13  *   Version $Id$
14  */
15 /*
16    Copyright (C) 2000-2004 Kern Sibbald and John Walker
17
18    This program is free software; you can redistribute it and/or
19    modify it under the terms of the GNU General Public License as
20    published by the Free Software Foundation; either version 2 of
21    the License, or (at your option) any later version.
22
23    This program is distributed in the hope that it will be useful,
24    but WITHOUT ANY WARRANTY; without even the implied warranty of
25    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
26    General Public License for more details.
27
28    You should have received a copy of the GNU General Public
29    License along with this program; if not, write to the Free
30    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
31    MA 02111-1307, USA.
32
33  */
34
35 #include "bacula.h"
36 #include "dird.h"
37
38 /* Commands sent to File daemon */
39 static char inc[]         = "include\n";
40 static char exc[]         = "exclude\n";
41 static char fileset[]     = "fileset\n"; /* set full fileset */
42 static char jobcmd[]      = "JobId=%d Job=%s SDid=%u SDtime=%u Authorization=%s\n";
43 /* Note, mtime_only is not used here -- implemented as file option */
44 static char levelcmd[]    = "level = %s%s mtime_only=%d\n";
45 static char runbefore[]   = "RunBeforeJob %s\n";
46 static char runafter[]    = "RunAfterJob %s\n";
47
48
49 /* Responses received from File daemon */
50 static char OKinc[]       = "2000 OK include\n";
51 static char OKexc[]       = "2000 OK exclude\n";
52 static char OKjob[]       = "2000 OK Job";
53 static char OKbootstrap[] = "2000 OK bootstrap\n";
54 static char OKlevel[]     = "2000 OK level\n";
55 static char OKRunBefore[] = "2000 OK RunBefore\n";
56 static char OKRunAfter[]  = "2000 OK RunAfter\n";
57
58 /* Forward referenced functions */
59
60 /* External functions */
61 extern int debug_level;
62 extern DIRRES *director; 
63 extern int FDConnectTimeout;
64
65 #define INC_LIST 0
66 #define EXC_LIST 1
67
68 /*
69  * Open connection with File daemon. 
70  * Try connecting every retry_interval (default 10 sec), and
71  *   give up after max_retry_time (default 30 mins).
72  */
73
74 int connect_to_file_daemon(JCR *jcr, int retry_interval, int max_retry_time,
75                            int verbose)
76 {
77    BSOCK   *fd;
78
79    fd = bnet_connect(jcr, retry_interval, max_retry_time,
80         _("File daemon"), jcr->client->address, 
81         NULL, jcr->client->FDport, verbose);
82    if (fd == NULL) {
83       set_jcr_job_status(jcr, JS_ErrorTerminated);
84       return 0;
85    }
86    Dmsg0(10, "Opened connection with File daemon\n");
87    fd->res = (RES *)jcr->client;      /* save resource in BSOCK */
88    jcr->file_bsock = fd;
89    set_jcr_job_status(jcr, JS_Running);
90
91    if (!authenticate_file_daemon(jcr)) {
92       set_jcr_job_status(jcr, JS_ErrorTerminated);
93       return 0;
94    }
95         
96    /*
97     * Now send JobId and authorization key
98     */
99    bnet_fsend(fd, jobcmd, jcr->JobId, jcr->Job, jcr->VolSessionId, 
100       jcr->VolSessionTime, jcr->sd_auth_key);
101    if (strcmp(jcr->sd_auth_key, "dummy") != 0) {
102       memset(jcr->sd_auth_key, 0, strlen(jcr->sd_auth_key));
103    }
104    Dmsg1(100, ">filed: %s", fd->msg);
105    if (bget_dirmsg(fd) > 0) {
106        Dmsg1(110, "<filed: %s", fd->msg);
107        if (strncmp(fd->msg, OKjob, strlen(OKjob)) != 0) {
108           Jmsg(jcr, M_FATAL, 0, _("File daemon \"%s\" rejected Job command: %s\n"), 
109              jcr->client->hdr.name, fd->msg);
110           set_jcr_job_status(jcr, JS_ErrorTerminated);
111           return 0;
112        } else if (jcr->db) {
113           CLIENT_DBR cr;
114           memset(&cr, 0, sizeof(cr));
115           bstrncpy(cr.Name, jcr->client->hdr.name, sizeof(cr.Name));
116           cr.AutoPrune = jcr->client->AutoPrune;
117           cr.FileRetention = jcr->client->FileRetention;
118           cr.JobRetention = jcr->client->JobRetention;
119           bstrncpy(cr.Uname, fd->msg+strlen(OKjob)+1, sizeof(cr.Uname));
120           if (!db_update_client_record(jcr, jcr->db, &cr)) {
121              Jmsg(jcr, M_WARNING, 0, _("Error updating Client record. ERR=%s\n"),
122                 db_strerror(jcr->db));
123           }
124        }
125    } else {
126       Jmsg(jcr, M_FATAL, 0, _("FD gave bad response to JobId command: %s\n"),
127          bnet_strerror(fd));
128       set_jcr_job_status(jcr, JS_ErrorTerminated);
129       return 0;
130    }
131    return 1;
132 }
133
134 /*
135  * This subroutine edits the last job start time into a
136  *   "since=date/time" buffer that is returned in the  
137  *   variable since.  This is used for display purposes in
138  *   the job report.  The time in jcr->stime is later 
139  *   passed to tell the File daemon what to do.
140  */
141 void get_level_since_time(JCR *jcr, char *since, int since_len)
142 {
143    /* Lookup the last
144     * FULL backup job to get the time/date for a 
145     * differential or incremental save.
146     */
147    if (!jcr->stime) {
148       jcr->stime = get_pool_memory(PM_MESSAGE);
149    }
150    jcr->stime[0] = 0;
151    since[0] = 0;
152    switch (jcr->JobLevel) {
153    case L_DIFFERENTIAL:
154    case L_INCREMENTAL:
155       /* Look up start time of last job */
156       jcr->jr.JobId = 0;
157       if (!db_find_job_start_time(jcr, jcr->db, &jcr->jr, &jcr->stime)) {
158          Jmsg(jcr, M_INFO, 0, "%s", db_strerror(jcr->db));
159          Jmsg(jcr, M_INFO, 0, _("No prior or suitable Full backup found. Doing FULL backup.\n"));
160          bsnprintf(since, since_len, " (upgraded from %s)", 
161             level_to_str(jcr->JobLevel));
162          jcr->JobLevel = jcr->jr.Level = L_FULL;
163       } else {
164          bstrncpy(since, ", since=", since_len);
165          bstrncat(since, jcr->stime, since_len);
166       }
167       Dmsg1(100, "Last start time = %s\n", jcr->stime);
168       break;
169    }
170 }
171
172
173 /*
174  * Send level command to FD. 
175  * Used for backup jobs and estimate command.
176  */
177 int send_level_command(JCR *jcr) 
178 {
179    BSOCK   *fd = jcr->file_bsock;
180    utime_t stime;
181    char ed1[50];
182    /* 
183     * Send Level command to File daemon
184     */
185    switch (jcr->JobLevel) {
186    case L_BASE:
187       bnet_fsend(fd, levelcmd, "base", " ", 0);
188       break;
189    /* L_NONE is the console, sending something off to the FD */
190    case L_NONE:
191    case L_FULL:
192       bnet_fsend(fd, levelcmd, "full", " ", 0);
193       break;
194    case L_DIFFERENTIAL:
195    case L_INCREMENTAL:
196 //    bnet_fsend(fd, levelcmd, "since ", jcr->stime, 0); /* old code, deprecated */
197       stime = str_to_utime(jcr->stime);
198       bnet_fsend(fd, levelcmd, "since_utime ", edit_uint64(stime, ed1), 0);
199       while (bget_dirmsg(fd) >= 0) {  /* allow him to poll us to sync clocks */
200          Jmsg(jcr, M_INFO, 0, "%s\n", fd->msg);
201       }
202       break;
203    case L_SINCE:
204    default:
205       Jmsg2(jcr, M_FATAL, 0, _("Unimplemented backup level %d %c\n"), 
206          jcr->JobLevel, jcr->JobLevel);
207       return 0;
208    }
209    Dmsg1(120, ">filed: %s", fd->msg);
210    if (!response(jcr, fd, OKlevel, "Level", DISPLAY_ERROR)) {
211       return 0;
212    }
213    return 1;
214 }
215
216
217 /*
218  * Send either an Included or an Excluded list to FD
219  */
220 static int send_list(JCR *jcr, int list)
221 {
222    FILESET *fileset;
223    BSOCK   *fd;
224    int num;
225
226    fd = jcr->file_bsock;
227    fileset = jcr->fileset;
228
229    if (list == INC_LIST) {
230       num = fileset->num_includes;
231    } else {
232       num = fileset->num_excludes;
233    }
234
235    for (int i=0; i<num; i++) {
236       BPIPE *bpipe;
237       FILE *ffd;
238       char buf[2000];
239       char *p;
240       int optlen, stat;
241       INCEXE *ie;
242
243
244       if (list == INC_LIST) {
245          ie = fileset->include_items[i];
246       } else {
247          ie = fileset->exclude_items[i];
248       }
249       for (int j=0; j<ie->name_list.size(); j++) {
250          p = (char *)ie->name_list.get(j);
251          switch (*p) {
252          case '|':
253             p++;                      /* skip over the | */
254             fd->msg = edit_job_codes(jcr, fd->msg, p, "");
255             bpipe = open_bpipe(fd->msg, 0, "r");
256             if (!bpipe) {
257                Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
258                   p, strerror(errno));
259                goto bail_out;
260             }
261             /* Copy File options */
262             if (ie->num_opts) {
263                bstrncpy(buf, ie->opts_list[0]->opts, sizeof(buf));
264                bstrncat(buf, " ", sizeof(buf));
265             } else {
266                bstrncpy(buf, "0 ", sizeof(buf));
267             }
268             Dmsg1(500, "Opts=%s\n", buf);
269             optlen = strlen(buf);
270             while (fgets(buf+optlen, sizeof(buf)-optlen, bpipe->rfd)) {
271                fd->msglen = Mmsg(&fd->msg, "%s", buf);
272                Dmsg2(500, "Inc/exc len=%d: %s", fd->msglen, fd->msg);
273                if (!bnet_send(fd)) {
274                   Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
275                   goto bail_out;
276                }
277             }
278             if ((stat=close_bpipe(bpipe)) != 0) {
279                Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. RtnStat=%d ERR=%s\n"),
280                   p, stat, strerror(errno));
281                goto bail_out;
282             }
283             break;
284          case '<':
285             p++;                      /* skip over < */
286             if ((ffd = fopen(p, "r")) == NULL) {
287                Jmsg(jcr, M_FATAL, 0, _("Cannot open %s file: %s. ERR=%s\n"),
288                   list==INC_LIST?"included":"excluded", p, strerror(errno));
289                goto bail_out;
290             }
291             /* Copy File options */
292             if (ie->num_opts) {
293                bstrncpy(buf, ie->opts_list[0]->opts, sizeof(buf));
294                bstrncat(buf, " ", sizeof(buf));
295             } else {
296                bstrncpy(buf, "0 ", sizeof(buf));
297             }
298             Dmsg1(500, "Opts=%s\n", buf);
299             optlen = strlen(buf);
300             while (fgets(buf+optlen, sizeof(buf)-optlen, ffd)) {
301                fd->msglen = Mmsg(&fd->msg, "%s", buf);
302                if (!bnet_send(fd)) {
303                   Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
304                   goto bail_out;
305                }
306             }
307             fclose(ffd);
308             break;
309          case '\\':
310             p++;                      /* skip over \ */
311             /* Note, fall through wanted */
312          default:
313             if (ie->num_opts) {
314                Dmsg2(500, "numopts=%d opts=%s\n", ie->num_opts, NPRT(ie->opts_list[0]->opts));
315                pm_strcpy(&fd->msg, ie->opts_list[0]->opts);
316                pm_strcat(&fd->msg, " ");
317             } else {
318                pm_strcpy(&fd->msg, "0 ");
319             }
320             fd->msglen = pm_strcat(&fd->msg, p);
321             Dmsg1(500, "Inc/Exc name=%s\n", fd->msg);
322             if (!bnet_send(fd)) {
323                Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
324                goto bail_out;
325             }
326             break;
327          }
328       }
329    }
330    bnet_sig(fd, BNET_EOD);            /* end of data */
331    if (list == INC_LIST) {
332       if (!response(jcr, fd, OKinc, "Include", DISPLAY_ERROR)) {
333          goto bail_out;
334       }
335    } else if (!response(jcr, fd, OKexc, "Exclude", DISPLAY_ERROR)) {
336         goto bail_out;
337    }
338    return 1;
339
340 bail_out:
341    set_jcr_job_status(jcr, JS_ErrorTerminated);
342    return 0;
343
344 }
345
346
347 /*
348  * Send either an Included or an Excluded list to FD
349  */
350 static int send_fileset(JCR *jcr)
351 {
352    FILESET *fileset = jcr->fileset;
353    BSOCK   *fd = jcr->file_bsock;
354    int num;
355    bool include = true;
356
357    for ( ;; ) {
358       if (include) {
359          num = fileset->num_includes;
360       } else {
361          num = fileset->num_excludes;
362       }  
363       for (int i=0; i<num; i++) {
364          BPIPE *bpipe;
365          FILE *ffd;
366          char buf[2000];
367          char *p;
368          int optlen, stat;
369          INCEXE *ie;
370          int j, k;
371
372          if (include) {
373             ie = fileset->include_items[i];
374             bnet_fsend(fd, "I\n");
375          } else {
376             ie = fileset->exclude_items[i];
377             bnet_fsend(fd, "E\n");
378          }       
379          for (j=0; j<ie->num_opts; j++) {
380             FOPTS *fo = ie->opts_list[j];
381             bnet_fsend(fd, "O %s\n", fo->opts);
382             for (k=0; k<fo->regex.size(); k++) {
383                bnet_fsend(fd, "R %s\n", fo->regex.get(k));
384             }
385             for (k=0; k<fo->wild.size(); k++) {
386                bnet_fsend(fd, "W %s\n", fo->wild.get(k));
387             }
388             for (k=0; k<fo->base.size(); k++) {
389                bnet_fsend(fd, "B %s\n", fo->base.get(k));
390             }
391             bnet_fsend(fd, "N\n");
392          }
393
394          for (j=0; j<ie->name_list.size(); j++) {
395             p = (char *)ie->name_list.get(j);
396             switch (*p) {
397             case '|':
398                p++;                      /* skip over the | */
399                fd->msg = edit_job_codes(jcr, fd->msg, p, "");
400                bpipe = open_bpipe(fd->msg, 0, "r");
401                if (!bpipe) {
402                   Jmsg(jcr, M_FATAL, 0, _("Cannot run program: %s. ERR=%s\n"),
403                      p, strerror(errno));
404                   goto bail_out;
405                }
406                bstrncpy(buf, "F ", sizeof(buf));
407                Dmsg1(500, "Opts=%s\n", buf);
408                optlen = strlen(buf);
409                while (fgets(buf+optlen, sizeof(buf)-optlen, bpipe->rfd)) {
410                   fd->msglen = Mmsg(&fd->msg, "%s", buf);
411                   Dmsg2(500, "Inc/exc len=%d: %s", fd->msglen, fd->msg);
412                   if (!bnet_send(fd)) {
413                      Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
414                      goto bail_out;
415                   }
416                }
417                if ((stat=close_bpipe(bpipe)) != 0) {
418                   Jmsg(jcr, M_FATAL, 0, _("Error running program: %s. RtnStat=%d ERR=%s\n"),
419                      p, stat, strerror(errno));
420                   goto bail_out;
421                }
422                break;
423             case '<':
424                p++;                      /* skip over < */
425                if ((ffd = fopen(p, "r")) == NULL) {
426                   Jmsg(jcr, M_FATAL, 0, _("Cannot open included file: %s. ERR=%s\n"),
427                      p, strerror(errno));
428                   goto bail_out;
429                }
430                bstrncpy(buf, "F ", sizeof(buf));
431                Dmsg1(500, "Opts=%s\n", buf);
432                optlen = strlen(buf);
433                while (fgets(buf+optlen, sizeof(buf)-optlen, ffd)) {
434                   fd->msglen = Mmsg(&fd->msg, "%s", buf);
435                   if (!bnet_send(fd)) {
436                      Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
437                      goto bail_out;
438                   }
439                }
440                fclose(ffd);
441                break;
442             case '\\':
443                p++;                      /* skip over \ */
444                /* Note, fall through wanted */
445             default:
446                pm_strcpy(&fd->msg, "F ");
447                fd->msglen = pm_strcat(&fd->msg, p);
448                Dmsg1(500, "Inc/Exc name=%s\n", fd->msg);
449                if (!bnet_send(fd)) {
450                   Jmsg(jcr, M_FATAL, 0, _(">filed: write error on socket\n"));
451                   goto bail_out;
452                }
453                break;
454             }
455          }
456          bnet_fsend(fd, "N\n");
457       }
458       if (!include) {                 /* If we just did excludes */
459          break;                       /*   all done */
460       }
461       include = false;                /* Now do excludes */
462    }
463
464    bnet_sig(fd, BNET_EOD);            /* end of data */
465    if (!response(jcr, fd, OKinc, "Include", DISPLAY_ERROR)) {
466       goto bail_out;
467    }
468    return 1;
469
470 bail_out:
471    set_jcr_job_status(jcr, JS_ErrorTerminated);
472    return 0;
473
474 }
475
476
477 /*
478  * Send include list to File daemon
479  */
480 int send_include_list(JCR *jcr)
481 {
482    BSOCK *fd = jcr->file_bsock;
483    if (jcr->fileset->new_include) {
484       bnet_fsend(fd, fileset);
485       return send_fileset(jcr);
486    } else {
487       bnet_fsend(fd, inc);
488    }
489    return send_list(jcr, INC_LIST);
490 }
491
492
493 /*
494  * Send exclude list to File daemon 
495  */
496 int send_exclude_list(JCR *jcr)
497 {
498    BSOCK *fd = jcr->file_bsock;
499    if (jcr->fileset->new_include) {
500       return 1;
501    }
502    bnet_fsend(fd, exc);
503    return send_list(jcr, EXC_LIST);
504 }
505
506
507 /*
508  * Send bootstrap file if any to the File daemon.
509  *  This is used for restore and verify VolumeToCatalog
510  */
511 int send_bootstrap_file(JCR *jcr)
512 {
513    FILE *bs;
514    char buf[1000];
515    BSOCK *fd = jcr->file_bsock;
516    const char *bootstrap = "bootstrap\n";
517
518    Dmsg1(400, "send_bootstrap_file: %s\n", jcr->RestoreBootstrap);
519    if (!jcr->RestoreBootstrap) {
520       return 1;
521    }
522    bs = fopen(jcr->RestoreBootstrap, "r");
523    if (!bs) {
524       Jmsg(jcr, M_FATAL, 0, _("Could not open bootstrap file %s: ERR=%s\n"), 
525          jcr->RestoreBootstrap, strerror(errno));
526       set_jcr_job_status(jcr, JS_ErrorTerminated);
527       return 0;
528    }
529    bnet_fsend(fd, bootstrap);
530    while (fgets(buf, sizeof(buf), bs)) {
531       bnet_fsend(fd, "%s", buf);       
532    }
533    bnet_sig(fd, BNET_EOD);
534    fclose(bs);
535    if (!response(jcr, fd, OKbootstrap, "Bootstrap", DISPLAY_ERROR)) {
536       set_jcr_job_status(jcr, JS_ErrorTerminated);
537       return 0;
538    }
539    return 1;
540 }
541
542 /*
543  * Send ClientRunBeforeJob and ClientRunAfterJob to File daemon
544  */
545 int send_run_before_and_after_commands(JCR *jcr)
546 {
547    POOLMEM *msg = get_pool_memory(PM_FNAME);
548    BSOCK *fd = jcr->file_bsock;
549    if (jcr->job->ClientRunBeforeJob) {
550       pm_strcpy(&msg, jcr->job->ClientRunBeforeJob);
551       bash_spaces(msg);
552       bnet_fsend(fd, runbefore, msg);
553       if (!response(jcr, fd, OKRunBefore, "ClientRunBeforeJob", DISPLAY_ERROR)) {
554          set_jcr_job_status(jcr, JS_ErrorTerminated);
555          free_pool_memory(msg);
556          return 0;
557       }
558    }
559    if (jcr->job->ClientRunAfterJob) {
560       fd->msglen = pm_strcpy(&msg, jcr->job->ClientRunAfterJob);
561       bash_spaces(msg);
562       bnet_fsend(fd, runafter, msg);
563       if (!response(jcr, fd, OKRunAfter, "ClientRunAfterJob", DISPLAY_ERROR)) {
564          set_jcr_job_status(jcr, JS_ErrorTerminated);
565          free_pool_memory(msg);
566          return 0;
567       }
568    }
569    free_pool_memory(msg);
570    return 1;
571 }
572
573
574 /* 
575  * Read the attributes from the File daemon for
576  * a Verify job and store them in the catalog.
577  */
578 int get_attributes_and_put_in_catalog(JCR *jcr)
579 {
580    BSOCK   *fd;
581    int n = 0;
582    ATTR_DBR ar;
583
584    fd = jcr->file_bsock;
585    jcr->jr.FirstIndex = 1;
586    memset(&ar, 0, sizeof(ar));
587    jcr->FileIndex = 0;
588
589    Dmsg0(120, "bdird: waiting to receive file attributes\n");
590    /* Pickup file attributes and signature */
591    while (!fd->errors && (n = bget_dirmsg(fd)) > 0) {
592
593    /*****FIXME****** improve error handling to stop only on 
594     * really fatal problems, or the number of errors is too
595     * large.
596     */
597       long file_index;
598       int stream, len;
599       char *attr, *p, *fn;
600       char Opts_SIG[MAXSTRING];      /* either Verify opts or MD5/SHA1 signature */
601       char SIG[MAXSTRING];
602
603       jcr->fname = check_pool_memory_size(jcr->fname, fd->msglen);
604       if ((len = sscanf(fd->msg, "%ld %d %s", &file_index, &stream, Opts_SIG)) != 3) {
605          Jmsg(jcr, M_FATAL, 0, _("<filed: bad attributes, expected 3 fields got %d\n\
606 msglen=%d msg=%s\n"), len, fd->msglen, fd->msg);
607          set_jcr_job_status(jcr, JS_ErrorTerminated);
608          return 0;
609       }
610       p = fd->msg;
611       skip_nonspaces(&p);             /* skip FileIndex */
612       skip_spaces(&p);
613       skip_nonspaces(&p);             /* skip Stream */
614       skip_spaces(&p);
615       skip_nonspaces(&p);             /* skip Opts_SHA1 */   
616       p++;                            /* skip space */
617       fn = jcr->fname;
618       while (*p != 0) {
619          *fn++ = *p++;                /* copy filename */
620       }
621       *fn = *p++;                     /* term filename and point to attribs */
622       attr = p;
623
624       if (stream == STREAM_UNIX_ATTRIBUTES || stream == STREAM_UNIX_ATTRIBUTES_EX) {
625          jcr->JobFiles++;
626          jcr->FileIndex = file_index;
627          ar.attr = attr;
628          ar.fname = jcr->fname;
629          ar.FileIndex = file_index;
630          ar.Stream = stream;
631          ar.link = NULL;
632          ar.JobId = jcr->JobId;
633          ar.ClientId = jcr->ClientId;
634          ar.PathId = 0;
635          ar.FilenameId = 0;
636
637          Dmsg2(111, "dird<filed: stream=%d %s\n", stream, jcr->fname);
638          Dmsg1(120, "dird<filed: attr=%s\n", attr);
639
640          if (!db_create_file_attributes_record(jcr, jcr->db, &ar)) {
641             Jmsg1(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
642             set_jcr_job_status(jcr, JS_Error);
643             continue;
644          }
645          jcr->FileId = ar.FileId;
646       } else if (stream == STREAM_MD5_SIGNATURE || stream == STREAM_SHA1_SIGNATURE) {
647          if (jcr->FileIndex != (uint32_t)file_index) {
648             Jmsg2(jcr, M_ERROR, 0, _("MD5/SHA1 index %d not same as attributes %d\n"),
649                file_index, jcr->FileIndex);
650             set_jcr_job_status(jcr, JS_Error);
651             continue;
652          }
653          db_escape_string(SIG, Opts_SIG, strlen(Opts_SIG));
654          Dmsg2(120, "SIGlen=%d SIG=%s\n", strlen(SIG), SIG);
655          if (!db_add_SIG_to_file_record(jcr, jcr->db, jcr->FileId, SIG, 
656                    stream==STREAM_MD5_SIGNATURE?MD5_SIG:SHA1_SIG)) {
657             Jmsg1(jcr, M_ERROR, 0, "%s", db_strerror(jcr->db));
658             set_jcr_job_status(jcr, JS_Error);
659          }
660       }
661       jcr->jr.JobFiles = jcr->JobFiles = file_index;
662       jcr->jr.LastIndex = file_index;
663    } 
664    if (is_bnet_error(fd)) {
665       Jmsg1(jcr, M_FATAL, 0, _("<filed: Network error getting attributes. ERR=%s\n"),
666                         bnet_strerror(fd));
667       set_jcr_job_status(jcr, JS_ErrorTerminated);
668       return 0;
669    }
670
671    set_jcr_job_status(jcr, JS_Terminated);
672    return 1;
673 }