]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/expand.c
Apply Preben 'Peppe' Guldberg <peppe@wielders.org>
[bacula/bacula] / bacula / src / dird / expand.c
1 /*
2  *
3  *   Bacula Director -- expand.c -- does variable expansion
4  *    in particular for the LabelFormat specification.
5  *
6  *     Kern Sibbald, June MMIII
7  *
8  *   Version $Id$
9  */
10 /*
11    Copyright (C) 2003-2004 Kern Sibbald and John Walker
12
13    This program is free software; you can redistribute it and/or
14    modify it under the terms of the GNU General Public License as
15    published by the Free Software Foundation; either version 2 of
16    the License, or (at your option) any later version.
17
18    This program is distributed in the hope that it will be useful,
19    but WITHOUT ANY WARRANTY; without even the implied warranty of
20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21    General Public License for more details.
22
23    You should have received a copy of the GNU General Public
24    License along with this program; if not, write to the Free
25    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
26    MA 02111-1307, USA.
27
28  */
29
30 #include "bacula.h"
31 #include "dird.h"
32
33
34
35 static int date_item(JCR *jcr, int code,
36               const char **val_ptr, int *val_len, int *val_size)
37 {
38    struct tm tm;
39    time_t now = time(NULL);
40    localtime_r(&now, &tm);
41    int val = 0;
42    char buf[10];
43
44    switch (code) {
45    case 1:                            /* year */
46       val = tm.tm_year + 1900;
47       break;
48    case 2:                            /* month */
49       val = tm.tm_mon + 1;
50       break;
51    case 3:                            /* day */
52       val = tm.tm_mday;
53       break;
54    case 4:                            /* hour */
55       val = tm.tm_hour;
56       break;
57    case 5:                            /* minute */
58       val = tm.tm_min;
59       break;
60    case 6:                            /* second */
61       val = tm.tm_sec;
62       break;
63    case 7:                            /* Week day */
64       val = tm.tm_wday;
65       break;
66    }
67    bsnprintf(buf, sizeof(buf), "%d", val);
68    *val_ptr = bstrdup(buf);
69    *val_len = strlen(buf);
70    *val_size = *val_len + 1;
71    return 1;
72 }
73
74 static int job_item(JCR *jcr, int code,
75               const char **val_ptr, int *val_len, int *val_size)
76 {
77    const char *str = " ";
78    char buf[20];
79
80    switch (code) {
81    case 1:                            /* Job */
82       str = jcr->job->hdr.name;
83       break;
84    case 2:                            /* Director's name */
85       str = my_name;
86       break;
87    case 3:                            /* level */
88       str = job_level_to_str(jcr->JobLevel);
89       break;
90    case 4:                            /* type */
91       str = job_type_to_str(jcr->JobType);
92       break;
93    case 5:                            /* JobId */
94       bsnprintf(buf, sizeof(buf), "%d", jcr->JobId);
95       str = buf;
96       break;
97    case 6:                            /* Client */
98       str = jcr->client->hdr.name;
99       if (!str) {
100          str = " ";
101       }
102       break;
103    case 7:                            /* NumVols */
104       bsnprintf(buf, sizeof(buf), "%d", jcr->NumVols);
105       str = buf;
106       break;
107    case 8:                            /* Pool */
108       str = jcr->pool->hdr.name;
109       break;
110    case 9:                            /* Storage */
111       str = jcr->store->hdr.name;
112       break;
113    case 10:                           /* Catalog */
114       str = jcr->catalog->hdr.name;
115       break;
116    case 11:                           /* MediaType */
117       str = jcr->store->media_type;
118       break;
119    case 12:                           /* JobName */
120       str = jcr->Job;
121       break;
122    }
123    *val_ptr = bstrdup(str);
124    *val_len = strlen(str);
125    *val_size = *val_len + 1;
126    return 1;
127 }
128
129
130 struct s_built_in_vars {const char *var_name; int code; int (*func)(JCR *jcr, int code,
131                          const char **val_ptr, int *val_len, int *val_size);};
132
133 /*
134  * Table of build in variables
135  */
136 static struct s_built_in_vars built_in_vars[] = {
137    { N_("Year"),       1, date_item},
138    { N_("Month"),      2, date_item},
139    { N_("Day"),        3, date_item},
140    { N_("Hour"),       4, date_item},
141    { N_("Minute"),     5, date_item},
142    { N_("Second"),     6, date_item},
143    { N_("WeekDay"),    7, date_item},
144
145    { N_("Job"),        1, job_item},
146    { N_("Dir"),        2, job_item},
147    { N_("Level"),      3, job_item},
148    { N_("Type"),       4, job_item},
149    { N_("JobId"),      5, job_item},
150    { N_("Client"),     6, job_item},
151    { N_("NumVols"),    7, job_item},
152    { N_("Pool"),       8, job_item},
153    { N_("Storage"),    9, job_item},
154    { N_("Catalog"),   10, job_item},
155    { N_("MediaType"), 11, job_item},
156    { N_("JobName"),   12, job_item},
157
158    { NULL, 0, NULL}
159 };
160
161
162 /*
163  * Search the table of built-in variables, and if found,
164  *   call the appropriate subroutine to do the work.
165  */
166 static var_rc_t lookup_built_in_var(var_t *ctx, void *my_ctx,
167           const char *var_ptr, int var_len, int var_index,
168           const char **val_ptr, int *val_len, int *val_size)
169 {
170    JCR *jcr = (JCR *)my_ctx;
171    int stat;
172
173    for (int i=0; _(built_in_vars[i].var_name); i++) {
174       if (strncmp(_(built_in_vars[i].var_name), var_ptr, var_len) == 0) {
175          stat = (*built_in_vars[i].func)(jcr, built_in_vars[i].code,
176             val_ptr, val_len, val_size);
177          if (stat) {
178             return VAR_OK;
179          }
180          break;
181       }
182    }
183    return VAR_ERR_UNDEFINED_VARIABLE;
184 }
185
186
187 /*
188  * Search counter variables
189  */
190 static var_rc_t lookup_counter_var(var_t *ctx, void *my_ctx,
191           const char *var_ptr, int var_len, int var_inc, int var_index,
192           const char **val_ptr, int *val_len, int *val_size)
193 {
194    char buf[MAXSTRING];
195    var_rc_t stat = VAR_ERR_UNDEFINED_VARIABLE;
196
197    if (var_len > (int)sizeof(buf) - 1) {
198        return VAR_ERR_OUT_OF_MEMORY;
199    }
200    memcpy(buf, var_ptr, var_len);
201    buf[var_len] = 0;
202    LockRes();
203    for (COUNTER *counter=NULL; (counter = (COUNTER *)GetNextRes(R_COUNTER, (RES *)counter)); ) {
204       if (strcmp(counter->hdr.name, buf) == 0) {
205          Dmsg2(100, "Counter=%s val=%d\n", buf, counter->CurrentValue);
206          /* -1 => return size of array */
207         if (var_index == -1) {
208             bsnprintf(buf, sizeof(buf), "%d", counter->CurrentValue);
209             *val_len = bsnprintf(buf, sizeof(buf), "%d", strlen(buf));
210             *val_ptr = buf;
211             *val_size = 0;                  /* don't try to free val_ptr */
212             return VAR_OK;
213          } else {
214             bsnprintf(buf, sizeof(buf), "%d", counter->CurrentValue);
215             *val_ptr = bstrdup(buf);
216             *val_len = strlen(buf);
217             *val_size = *val_len + 1;
218          }
219          if (var_inc) {               /* increment the variable? */
220             if (counter->CurrentValue == counter->MaxValue) {
221                counter->CurrentValue = counter->MinValue;
222             } else {
223                counter->CurrentValue++;
224             }
225             if (counter->Catalog) {   /* update catalog if need be */
226                COUNTER_DBR cr;
227                JCR *jcr = (JCR *)my_ctx;
228                memset(&cr, 0, sizeof(cr));
229                bstrncpy(cr.Counter, counter->hdr.name, sizeof(cr.Counter));
230                cr.MinValue = counter->MinValue;
231                cr.MaxValue = counter->MaxValue;
232                cr.CurrentValue = counter->CurrentValue;
233                Dmsg1(100, "New value=%d\n", cr.CurrentValue);
234                if (counter->WrapCounter) {
235                   bstrncpy(cr.WrapCounter, counter->WrapCounter->hdr.name, sizeof(cr.WrapCounter));
236                } else {
237                   cr.WrapCounter[0] = 0;
238                }
239                if (!db_update_counter_record(jcr, jcr->db, &cr)) {
240                   Jmsg(jcr, M_ERROR, 0, _("Count not update counter %s: ERR=%s\n"),
241                      counter->hdr.name, db_strerror(jcr->db));
242                }
243             }
244          }
245          stat = VAR_OK;
246          break;
247       }
248    }
249    UnlockRes();
250    return stat;
251 }
252
253
254 /*
255  * Called here from "core" expand code to look up a variable
256  */
257 static var_rc_t lookup_var(var_t *ctx, void *my_ctx,
258           const char *var_ptr, int var_len, int var_inc, int var_index,
259           const char **val_ptr, int *val_len, int *val_size)
260 {
261    char buf[MAXSTRING], *val, *p, *v;
262    var_rc_t stat;
263    int count;
264
265    /* Note, if val_size > 0 and val_ptr!=NULL, the core code will free() it */
266    if ((stat = lookup_built_in_var(ctx, my_ctx, var_ptr, var_len, var_index,
267         val_ptr, val_len, val_size)) == VAR_OK) {
268       return VAR_OK;
269    }
270
271    if ((stat = lookup_counter_var(ctx, my_ctx, var_ptr, var_len, var_inc, var_index,
272         val_ptr, val_len, val_size)) == VAR_OK) {
273       return VAR_OK;
274    }
275
276    /* Look in environment */
277    if (var_len > (int)sizeof(buf) - 1) {
278        return VAR_ERR_OUT_OF_MEMORY;
279    }
280    memcpy(buf, var_ptr, var_len + 1);
281    buf[var_len] = 0;
282    Dmsg1(100, "Var=%s\n", buf);
283
284    if ((val = getenv(buf)) == NULL) {
285        return VAR_ERR_UNDEFINED_VARIABLE;
286    }
287    /* He wants to index the "array" */
288    count = 1;
289    /* Find the size of the "array"
290     *   each element is separated by a |
291     */
292    for (p = val; *p; p++) {
293       if (*p == '|') {
294          count++;
295       }
296    }
297    Dmsg3(100, "For %s, reqest index=%d have=%d\n",
298       buf, var_index, count);
299
300    /* -1 => return size of array */
301    if (var_index == -1) {
302       int len;
303       if (count == 1) {               /* if not array */
304          len = strlen(val);           /* return length of string */
305       } else {
306          len = count;                 /* else return # array items */
307       }
308       *val_len = bsnprintf(buf, sizeof(buf), "%d", len);
309       *val_ptr = buf;
310       *val_size = 0;                  /* don't try to free val_ptr */
311       return VAR_OK;
312    }
313
314
315    if (var_index < -1 || var_index > --count) {
316 //    return VAR_ERR_SUBMATCH_OUT_OF_RANGE;
317       return VAR_ERR_UNDEFINED_VARIABLE;
318    }
319    /* Now find the particular item (var_index) he wants */
320    count = 0;
321    for (p=val; *p; ) {
322       if (*p == '|') {
323          if (count < var_index) {
324             val = ++p;
325             count++;
326             continue;
327          }
328          break;
329       }
330       p++;
331    }
332    if (p-val > (int)sizeof(buf) - 1) {
333        return VAR_ERR_OUT_OF_MEMORY;
334    }
335    Dmsg2(100, "val=%s len=%d\n", val, p-val);
336    /* Make a copy of item, and pass it back */
337    v = (char *)malloc(p-val+1);
338    memcpy(v, val, p-val);
339    v[p-val] = 0;
340    *val_ptr = v;
341    *val_len = p-val;
342    *val_size = p-val+1;
343    Dmsg1(100, "v=%s\n", v);
344    return VAR_OK;
345 }
346
347 /*
348  * Called here to do a special operation on a variable
349  *   op_ptr  points to the special operation code (not EOS terminated)
350  *   arg_ptr points to argument to special op code
351  *   val_ptr points to the value string
352  *   out_ptr points to string to be returned
353  */
354 static var_rc_t operate_var(var_t *var, void *my_ctx,
355           const char *op_ptr, int op_len,
356           const char *arg_ptr, int arg_len,
357           const char *val_ptr, int val_len,
358           char **out_ptr, int *out_len, int *out_size)
359 {
360    var_rc_t stat = VAR_ERR_UNDEFINED_OPERATION;
361    Dmsg0(100, "Enter operate_var\n");
362    if (!val_ptr) {
363       *out_size = 0;
364       return stat;
365    }
366    if (op_len == 3 && strncmp(op_ptr, "inc", 3) == 0) {
367       char buf[MAXSTRING];
368       if (val_len > (int)sizeof(buf) - 1) {
369           return VAR_ERR_OUT_OF_MEMORY;
370       }
371       memcpy(buf, arg_ptr, arg_len);
372       buf[arg_len] = 0;
373       Dmsg1(100, "Arg=%s\n", buf);
374       memcpy(buf, val_ptr, val_len);
375       buf[val_len] = 0;
376       Dmsg1(100, "Val=%s\n", buf);
377       LockRes();
378       for (COUNTER *counter=NULL; (counter = (COUNTER *)GetNextRes(R_COUNTER, (RES *)counter)); ) {
379          if (strcmp(counter->hdr.name, buf) == 0) {
380             Dmsg2(100, "counter=%s val=%s\n", counter->hdr.name, buf);
381             break;
382          }
383       }
384       UnlockRes();
385       return stat;
386    }
387    *out_size = 0;
388    return stat;
389 }
390
391
392 /*
393  * Expand an input line and return it.
394  *
395  *  Returns: 0 on failure
396  *           1 on success and exp has expanded input
397  */
398 int variable_expansion(JCR *jcr, char *inp, POOLMEM **exp)
399 {
400    var_t *var_ctx;
401    var_rc_t stat;
402    char *outp;
403    int in_len, out_len;
404    int rtn_stat = 0;
405
406    in_len = strlen(inp);
407    outp = NULL;
408    out_len = 0;
409
410    /* create context */
411    if ((stat = var_create(&var_ctx)) != VAR_OK) {
412        Jmsg(jcr, M_ERROR, 0, _("Cannot create var context: ERR=%s\n"), var_strerror(var_ctx, stat));
413        goto bail_out;
414    }
415    /* define callback */
416    if ((stat = var_config(var_ctx, VAR_CONFIG_CB_VALUE, lookup_var, (void *)jcr)) != VAR_OK) {
417        Jmsg(jcr, M_ERROR, 0, _("Cannot set var callback: ERR=%s\n"), var_strerror(var_ctx, stat));
418        goto bail_out;
419    }
420
421    /* define special operations */
422    if ((stat = var_config(var_ctx, VAR_CONFIG_CB_OPERATION, operate_var, (void *)jcr)) != VAR_OK) {
423        Jmsg(jcr, M_ERROR, 0, _("Cannot set var operate: ERR=%s\n"), var_strerror(var_ctx, stat));
424        goto bail_out;
425    }
426
427    /* unescape in place */
428    if ((stat = var_unescape(var_ctx, inp, in_len, inp, in_len+1, 0)) != VAR_OK) {
429        Jmsg(jcr, M_ERROR, 0, _("Cannot unescape string: ERR=%s\n"), var_strerror(var_ctx, stat));
430        goto bail_out;
431    }
432
433    in_len = strlen(inp);
434
435    /* expand variables */
436    if ((stat = var_expand(var_ctx, inp, in_len, &outp, &out_len, 0)) != VAR_OK) {
437        Jmsg(jcr, M_ERROR, 0, _("Cannot expand expression \"%s\": ERR=%s\n"),
438           inp, var_strerror(var_ctx, stat));
439        goto bail_out;
440    }
441
442    /* unescape once more in place */
443    if ((stat = var_unescape(var_ctx, outp, out_len, outp, out_len+1, 1)) != VAR_OK) {
444        Jmsg(jcr, M_ERROR, 0, _("Cannot unescape string: ERR=%s\n"), var_strerror(var_ctx, stat));
445        goto bail_out;
446    }
447
448    pm_strcpy(exp, outp);
449
450    rtn_stat = 1;
451
452 bail_out:
453    /* destroy expansion context */
454    if ((stat = var_destroy(var_ctx)) != VAR_OK) {
455        Jmsg(jcr, M_ERROR, 0, _("Cannot destroy var context: ERR=%s\n"), var_strerror(var_ctx, stat));
456    }
457    if (outp) {
458       free(outp);
459    }
460    return rtn_stat;
461 }