git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/cats.h

   1 /*
   2  * SQL header file
   3  *
   4  *   by Kern E. Sibbald
   5  *
   6  *   Anyone who accesses the database will need to include
   7  *   this file.
   8  *
   9  * This file contains definitions common to sql.c and
  10  * the external world, and definitions destined only
  11  * for the external world. This is control with
  12  * the define __SQL_C, which is defined only in sql.c
  13  *
  14  *    Version $Id$
  15  */
  16 /*
  17    Copyright (C) 2000-2006 Kern Sibbald
  18
  19    This program is free software; you can redistribute it and/or
  20    modify it under the terms of the GNU General Public License
  21    version 2 as amended with additional clauses defined in the
  22    file LICENSE in the main source directory.
  23
  24    This program is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  27    the file LICENSE for additional details.
  28
  29  */
  30
  31 /*
  32    Here is how database versions work.
  33
  34    While I am working on a new release with database changes, the
  35    update scripts are in the src/cats directory under the names
  36    update_xxx_tables.in.  Most of the time, I make database updates
  37    in one go and immediately update the version, but not always.  If
  38    there are going to be several updates as is the case with version
  39    1.37, then I will often forgo changing the version until the last
  40    update otherwise I will end up with too many versions and a lot
  41    of confusion.
  42
  43    When I am pretty sure there will be no more updates, I will
  44    change the version from 8 to 9 (in the present case), and when I
  45    am 100% sure there will be no more changes, the update script
  46    will be copied to the updatedb directory with the correct name
  47    (in the present case 8 to 9).
  48
  49    Now, in principle, each of the different DB implementations
  50    can have a different version, but in practice they are all
  51    the same (simplifies things). The exception is the internal
  52    database, which is no longer used, and hence, no longer changes.
  53  */
  54
  55
  56 #ifndef __SQL_H_
  57 #define __SQL_H_ 1
  58
  59
  60 typedef void (DB_LIST_HANDLER)(void *, const char *);
  61 typedef int (DB_RESULT_HANDLER)(void *, int, char **);
  62
  63 #define db_lock(mdb)   _db_lock(__FILE__, __LINE__, mdb)
  64 #define db_unlock(mdb) _db_unlock(__FILE__, __LINE__, mdb)
  65
  66 #ifdef __SQL_C
  67
  68 #if defined(BUILDING_CATS)
  69 #ifdef HAVE_SQLITE
  70
  71 #define BDB_VERSION 10
  72
  73 #include <sqlite.h>
  74
  75 /* Define opaque structure for sqlite */
  76 struct sqlite {
  77    char dummy;
  78 };
  79
  80 #define IS_NUM(x)             ((x) == 1)
  81 #define IS_NOT_NULL(x)        ((x) == 1)
  82
  83 typedef struct s_sql_field {
  84    char *name;                        /* name of column */
  85    int length;                        /* length */
  86    int max_length;                    /* max length */
  87    uint32_t type;                     /* type */
  88    uint32_t flags;                    /* flags */
  89 } SQL_FIELD;
  90
  91 /*
  92  * This is the "real" definition that should only be
  93  * used inside sql.c and associated database interface
  94  * subroutines.
  95  *                    S Q L I T E
  96  */
  97 struct B_DB {
  98    BQUEUE bq;                         /* queue control */
  99    brwlock_t lock;                    /* transaction lock */
 100    struct sqlite *db;
 101    char **result;
 102    int status;
 103    int nrow;                          /* nrow returned from sqlite */
 104    int ncolumn;                       /* ncolum returned from sqlite */
 105    int num_rows;                      /* used by code */
 106    int row;                           /* seek row */
 107    int field;                         /* seek field */
 108    SQL_FIELD **fields;                /* defined fields */
 109    int ref_count;
 110    char *db_name;
 111    char *db_user;
 112    char *db_address;                  /* host name address */
 113    char *db_socket;                   /* socket for local access */
 114    char *db_password;
 115    int  db_port;                      /* port for host name address */
 116    bool connected;                    /* connection made to db */
 117    bool have_insert_id;               /* do not have insert id */
 118    bool fields_defined;               /* set when fields defined */
 119    char *sqlite_errmsg;               /* error message returned by sqlite */
 120    POOLMEM *errmsg;                   /* nicely edited error message */
 121    POOLMEM *cmd;                      /* SQL command string */
 122    POOLMEM *cached_path;              /* cached path name */
 123    int cached_path_len;               /* length of cached path */
 124    uint32_t cached_path_id;           /* cached path id */
 125    bool allow_transactions;           /* transactions allowed */
 126    bool transaction;                  /* transaction started */
 127    int changes;                       /* changes during transaction */
 128    POOLMEM *fname;                    /* Filename only */
 129    POOLMEM *path;                     /* Path only */
 130    POOLMEM *esc_name;                 /* Escaped file/path name */
 131    int fnl;                           /* file name length */
 132    int pnl;                           /* path name length */
 133 };
 134
 135
 136 /*
 137  * "Generic" names for easier conversion
 138  *
 139  *                    S Q L I T E
 140  */
 141 #define sql_store_result(x)   (x)->result
 142 #define sql_free_result(x)    my_sqlite_free_table(x)
 143 #define sql_fetch_row(x)      my_sqlite_fetch_row(x)
 144 #define sql_query(x, y)       my_sqlite_query((x), (y))
 145 #ifdef HAVE_SQLITE3
 146 #define sql_insert_id(x,y)    sqlite3_last_insert_rowid((x)->db)
 147 #define sql_close(x)          sqlite3_close((x)->db)
 148 #else
 149 #define sql_insert_id(x,y)    sqlite_last_insert_rowid((x)->db)
 150 #define sql_close(x)          sqlite_close((x)->db)
 151 #endif
 152 #define sql_strerror(x)       (x)->sqlite_errmsg?(x)->sqlite_errmsg:"unknown"
 153 #define sql_num_rows(x)       (x)->nrow
 154 #define sql_data_seek(x, i)   (x)->row = (i)
 155 #define sql_affected_rows(x)  1
 156 #define sql_field_seek(x, y)  my_sqlite_field_seek((x), (y))
 157 #define sql_fetch_field(x)    my_sqlite_fetch_field(x)
 158 #define sql_num_fields(x)     ((x)->ncolumn)
 159 #define SQL_ROW               char**
 160
 161
 162
 163 /* In cats/sqlite.c */
 164 void       my_sqlite_free_table(B_DB *mdb);
 165 SQL_ROW    my_sqlite_fetch_row(B_DB *mdb);
 166 int        my_sqlite_query(B_DB *mdb, const char *cmd);
 167 void       my_sqlite_field_seek(B_DB *mdb, int field);
 168 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb);
 169
 170
 171 #else
 172
 173 /*                    S Q L I T E 3            */
 174
 175
 176 #ifdef HAVE_SQLITE3
 177
 178
 179 #define BDB_VERSION 10
 180
 181 #include <sqlite3.h>
 182
 183 /* Define opaque structure for sqlite */
 184 struct sqlite3 {
 185    char dummy;
 186 };
 187
 188 #define IS_NUM(x)             ((x) == 1)
 189 #define IS_NOT_NULL(x)        ((x) == 1)
 190
 191 typedef struct s_sql_field {
 192    char *name;                        /* name of column */
 193    int length;                        /* length */
 194    int max_length;                    /* max length */
 195    uint32_t type;                     /* type */
 196    uint32_t flags;                    /* flags */
 197 } SQL_FIELD;
 198
 199 /*
 200  * This is the "real" definition that should only be
 201  * used inside sql.c and associated database interface
 202  * subroutines.
 203  *                    S Q L I T E
 204  */
 205 struct B_DB {
 206    BQUEUE bq;                         /* queue control */
 207    brwlock_t lock;                    /* transaction lock */
 208    struct sqlite3 *db;
 209    char **result;
 210    int status;
 211    int nrow;                          /* nrow returned from sqlite */
 212    int ncolumn;                       /* ncolum returned from sqlite */
 213    int num_rows;                      /* used by code */
 214    int row;                           /* seek row */
 215    int field;                         /* seek field */
 216    SQL_FIELD **fields;                /* defined fields */
 217    int ref_count;
 218    char *db_name;
 219    char *db_user;
 220    char *db_address;                  /* host name address */
 221    char *db_socket;                   /* socket for local access */
 222    char *db_password;
 223    int  db_port;                      /* port for host name address */
 224    bool connected;                    /* connection made to db */
 225    bool have_insert_id;               /* do not have insert id */
 226    bool fields_defined;               /* set when fields defined */
 227    char *sqlite_errmsg;               /* error message returned by sqlite */
 228    POOLMEM *errmsg;                   /* nicely edited error message */
 229    POOLMEM *cmd;                      /* SQL command string */
 230    POOLMEM *cached_path;              /* cached path name */
 231    int cached_path_len;               /* length of cached path */
 232    uint32_t cached_path_id;           /* cached path id */
 233    bool allow_transactions;           /* transactions allowed */
 234    bool transaction;                  /* transaction started */
 235    int changes;                       /* changes during transaction */
 236    POOLMEM *fname;                    /* Filename only */
 237    POOLMEM *path;                     /* Path only */
 238    POOLMEM *esc_name;                 /* Escaped file/path name */
 239    int fnl;                           /* file name length */
 240    int pnl;                           /* path name length */
 241 };
 242
 243 /*
 244  * Conversion of sqlite 2 names to sqlite3
 245  */
 246 #define sqlite_last_insert_rowid sqlite3_last_insert_rowid
 247 #define sqlite_open sqlite3_open
 248 #define sqlite_close sqlite3_close
 249 #define sqlite_result sqlite3_result
 250 #define sqlite_exec sqlite3_exec
 251 #define sqlite_get_table sqlite3_get_table
 252 #define sqlite_free_table sqlite3_free_table
 253
 254
 255 /*
 256  * "Generic" names for easier conversion
 257  *
 258  *                    S Q L I T E 3
 259  */
 260 #define sql_store_result(x)   (x)->result
 261 #define sql_free_result(x)    my_sqlite_free_table(x)
 262 #define sql_fetch_row(x)      my_sqlite_fetch_row(x)
 263 #define sql_query(x, y)       my_sqlite_query((x), (y))
 264 #ifdef HAVE_SQLITE3
 265 #define sql_insert_id(x,y)    sqlite3_last_insert_rowid((x)->db)
 266 #define sql_close(x)          sqlite3_close((x)->db)
 267 #else
 268 #define sql_insert_id(x,y)    sqlite_last_insert_rowid((x)->db)
 269 #define sql_close(x)          sqlite_close((x)->db)
 270 #endif
 271 #define sql_strerror(x)       (x)->sqlite_errmsg?(x)->sqlite_errmsg:"unknown"
 272 #define sql_num_rows(x)       (x)->nrow
 273 #define sql_data_seek(x, i)   (x)->row = (i)
 274 #define sql_affected_rows(x)  1
 275 #define sql_field_seek(x, y)  my_sqlite_field_seek((x), (y))
 276 #define sql_fetch_field(x)    my_sqlite_fetch_field(x)
 277 #define sql_num_fields(x)     ((x)->ncolumn)
 278 #define SQL_ROW               char**
 279
 280
 281
 282 /* In cats/sqlite.c */
 283 void       my_sqlite_free_table(B_DB *mdb);
 284 SQL_ROW    my_sqlite_fetch_row(B_DB *mdb);
 285 int        my_sqlite_query(B_DB *mdb, const char *cmd);
 286 void       my_sqlite_field_seek(B_DB *mdb, int field);
 287 SQL_FIELD *my_sqlite_fetch_field(B_DB *mdb);
 288
 289
 290 #else
 291
 292 #ifdef HAVE_MYSQL
 293
 294 #define BDB_VERSION 10
 295
 296 #include <mysql.h>
 297
 298 /*
 299  * This is the "real" definition that should only be
 300  * used inside sql.c and associated database interface
 301  * subroutines.
 302  *
 303  *                     M Y S Q L
 304  */
 305 struct B_DB {
 306    BQUEUE bq;                         /* queue control */
 307    brwlock_t lock;                    /* transaction lock */
 308    MYSQL mysql;
 309    MYSQL *db;
 310    MYSQL_RES *result;
 311    int status;
 312    my_ulonglong num_rows;
 313    int ref_count;
 314    char *db_name;
 315    char *db_user;
 316    char *db_password;
 317    char *db_address;                  /* host address */
 318    char *db_socket;                   /* socket for local access */
 319    int db_port;                       /* port of host address */
 320    int have_insert_id;                /* do have insert_id() */
 321    bool connected;
 322    POOLMEM *errmsg;                   /* nicely edited error message */
 323    POOLMEM *cmd;                      /* SQL command string */
 324    POOLMEM *cached_path;
 325    int cached_path_len;               /* length of cached path */
 326    uint32_t cached_path_id;
 327    int changes;                       /* changes made to db */
 328    POOLMEM *fname;                    /* Filename only */
 329    POOLMEM *path;                     /* Path only */
 330    POOLMEM *esc_name;                 /* Escaped file/path name */
 331    int fnl;                           /* file name length */
 332    int pnl;                           /* path name length */
 333 };
 334
 335 #define DB_STATUS int
 336
 337 /* "Generic" names for easier conversion */
 338 #define sql_store_result(x)   mysql_store_result((x)->db)
 339 #define sql_use_result(x)     mysql_use_result((x)->db)
 340 #define sql_free_result(x)    mysql_free_result((x)->result)
 341 #define sql_fetch_row(x)      mysql_fetch_row((x)->result)
 342 #define sql_query(x, y)       mysql_query((x)->db, (y))
 343 #define sql_close(x)          mysql_close((x)->db)
 344 #define sql_strerror(x)       mysql_error((x)->db)
 345 #define sql_num_rows(x)       mysql_num_rows((x)->result)
 346 #define sql_data_seek(x, i)   mysql_data_seek((x)->result, (i))
 347 #define sql_affected_rows(x)  mysql_affected_rows((x)->db)
 348 #define sql_insert_id(x,y)    mysql_insert_id((x)->db)
 349 #define sql_field_seek(x, y)  mysql_field_seek((x)->result, (y))
 350 #define sql_fetch_field(x)    mysql_fetch_field((x)->result)
 351 #define sql_num_fields(x)     (int)mysql_num_fields((x)->result)
 352 #define SQL_ROW               MYSQL_ROW
 353 #define SQL_FIELD             MYSQL_FIELD
 354
 355 #else
 356
 357 #ifdef HAVE_POSTGRESQL
 358
 359 #define BDB_VERSION 10
 360
 361 #include <libpq-fe.h>
 362
 363 /* TEMP: the following is taken from select OID, typname from pg_type; */
 364 #define IS_NUM(x)        ((x) == 20 || (x) == 21 || (x) == 23 || (x) == 700 || (x) == 701)
 365 #define IS_NOT_NULL(x)   ((x) == 1)
 366
 367 typedef char **POSTGRESQL_ROW;
 368 typedef struct pg_field {
 369    char         *name;
 370    int           max_length;
 371    unsigned int  type;
 372    unsigned int  flags;       // 1 == not null
 373 } POSTGRESQL_FIELD;
 374
 375
 376 /*
 377  * This is the "real" definition that should only be
 378  * used inside sql.c and associated database interface
 379  * subroutines.
 380  *
 381  *                     P O S T G R E S Q L
 382  */
 383 struct B_DB {
 384    BQUEUE bq;                         /* queue control */
 385    brwlock_t lock;                    /* transaction lock */
 386    PGconn *db;
 387    PGresult *result;
 388    int status;
 389    POSTGRESQL_ROW row;
 390    POSTGRESQL_FIELD *fields;
 391    int num_rows;
 392    int num_fields;
 393    int row_number;            /* what row number did we get via my_postgresql_data_seek? */
 394    int field_number;          /* what field number did we get via my_postgresql_field_seek? */
 395    int ref_count;
 396    char *db_name;
 397    char *db_user;
 398    char *db_password;
 399    char *db_address;              /* host address */
 400    char *db_socket;               /* socket for local access */
 401    int db_port;                   /* port of host address */
 402    int have_insert_id;            /* do have insert_id() */
 403    bool connected;
 404    POOLMEM *errmsg;               /* nicely edited error message */
 405    POOLMEM *cmd;                  /* SQL command string */
 406    POOLMEM *cached_path;
 407    int cached_path_len;           /* length of cached path */
 408    uint32_t cached_path_id;
 409    bool allow_transactions;       /* transactions allowed */
 410    bool transaction;              /* transaction started */
 411    int changes;                   /* changes made to db */
 412    POOLMEM *fname;                /* Filename only */
 413    POOLMEM *path;                 /* Path only */
 414    POOLMEM *esc_name;             /* Escaped file/path name */
 415    int fnl;                       /* file name length */
 416    int pnl;                       /* path name length */
 417 };
 418
 419 void               my_postgresql_free_result(B_DB *mdb);
 420 POSTGRESQL_ROW     my_postgresql_fetch_row  (B_DB *mdb);
 421 int                my_postgresql_query      (B_DB *mdb, const char *query);
 422 void               my_postgresql_data_seek  (B_DB *mdb, int row);
 423 int                my_postgresql_currval    (B_DB *mdb, char *table_name);
 424 void               my_postgresql_field_seek (B_DB *mdb, int row);
 425 POSTGRESQL_FIELD * my_postgresql_fetch_field(B_DB *mdb);
 426
 427
 428 /* "Generic" names for easier conversion */
 429 #define sql_store_result(x)   ((x)->result)
 430 #define sql_free_result(x)    my_postgresql_free_result(x)
 431 #define sql_fetch_row(x)      my_postgresql_fetch_row(x)
 432 #define sql_query(x, y)       my_postgresql_query((x), (y))
 433 #define sql_close(x)          PQfinish((x)->db)
 434 #define sql_strerror(x)       PQresultErrorMessage((x)->result)
 435 #define sql_num_rows(x)       ((unsigned) PQntuples((x)->result))
 436 #define sql_data_seek(x, i)   my_postgresql_data_seek((x), (i))
 437 #define sql_affected_rows(x)  ((unsigned) atoi(PQcmdTuples((x)->result)))
 438 #define sql_insert_id(x,y)    my_postgresql_currval((x), (y))
 439 #define sql_field_seek(x, y)  my_postgresql_field_seek((x), (y))
 440 #define sql_fetch_field(x)    my_postgresql_fetch_field(x)
 441 #define sql_num_fields(x)     ((x)->num_fields)
 442 #define SQL_ROW               POSTGRESQL_ROW
 443 #define SQL_FIELD             POSTGRESQL_FIELD
 444
 445 #else  /* USE BACULA DB routines */
 446
 447 #define HAVE_BACULA_DB 1
 448
 449 /* Change this each time there is some incompatible
 450  * file format change!!!!
 451  */
 452 #define BDB_VERSION 13                /* file version number */
 453
 454 struct s_control {
 455    int bdb_version;                   /* Version number */
 456    uint32_t JobId;                    /* next Job Id */
 457    uint32_t PoolId;                   /* next Pool Id */
 458    uint32_t MediaId;                  /* next Media Id */
 459    uint32_t JobMediaId;               /* next JobMedia Id */
 460    uint32_t ClientId;                 /* next Client Id */
 461    uint32_t FileSetId;                /* nest FileSet Id */
 462    time_t time;                       /* time file written */
 463 };
 464
 465
 466 /* This is the REAL definition for using the
 467  *  Bacula internal DB
 468  */
 469 struct B_DB {
 470    BQUEUE bq;                         /* queue control */
 471 /* pthread_mutex_t mutex;  */         /* single thread lock */
 472    brwlock_t lock;                    /* transaction lock */
 473    int ref_count;                     /* number of times opened */
 474    struct s_control control;          /* control file structure */
 475    int cfd;                           /* control file device */
 476    FILE *jobfd;                       /* Jobs records file descriptor */
 477    FILE *poolfd;                      /* Pool records fd */
 478    FILE *mediafd;                     /* Media records fd */
 479    FILE *jobmediafd;                  /* JobMedia records fd */
 480    FILE *clientfd;                    /* Client records fd */
 481    FILE *filesetfd;                   /* FileSet records fd */
 482    char *db_name;                     /* name of database */
 483    POOLMEM *errmsg;                   /* nicely edited error message */
 484    POOLMEM *cmd;                      /* Command string */
 485    POOLMEM *cached_path;
 486    int cached_path_len;               /* length of cached path */
 487    uint32_t cached_path_id;
 488 };
 489
 490 #endif /* HAVE_SQLITE3 */
 491 #endif /* HAVE_MYSQL */
 492 #endif /* HAVE_SQLITE */
 493 #endif /* HAVE_POSTGRESQL */
 494 #endif
 495
 496 /* Use for better error location printing */
 497 #define UPDATE_DB(jcr, db, cmd) UpdateDB(__FILE__, __LINE__, jcr, db, cmd)
 498 #define INSERT_DB(jcr, db, cmd) InsertDB(__FILE__, __LINE__, jcr, db, cmd)
 499 #define QUERY_DB(jcr, db, cmd) QueryDB(__FILE__, __LINE__, jcr, db, cmd)
 500 #define DELETE_DB(jcr, db, cmd) DeleteDB(__FILE__, __LINE__, jcr, db, cmd)
 501
 502
 503 #else    /* not __SQL_C */
 504
 505 /* This is a "dummy" definition for use outside of sql.c
 506  */
 507 struct B_DB {
 508    int dummy;                         /* for SunOS compiler */
 509 };
 510
 511 #endif /*  __SQL_C */
 512
 513 extern uint32_t bacula_db_version;
 514
 515 /* ***FIXME*** FileId_t should *really* be uint64_t
 516  *  but at the current time, this breaks MySQL.
 517  */
 518 typedef uint32_t FileId_t;
 519 typedef uint32_t DBId_t;              /* general DB id type */
 520 typedef uint32_t JobId_t;
 521
 522 #define faddr_t long
 523
 524
 525 /* Job information passed to create job record and update
 526  * job record at end of job. Note, although this record
 527  * contains all the fields found in the Job database record,
 528  * it also contains fields found in the JobMedia record.
 529  */
 530 /* Job record */
 531 struct JOB_DBR {
 532    JobId_t JobId;
 533    char Job[MAX_NAME_LENGTH];         /* Job unique name */
 534    char Name[MAX_NAME_LENGTH];        /* Job base name */
 535    int JobType;                       /* actually char(1) */
 536    int JobLevel;                      /* actually char(1) */
 537    int JobStatus;                     /* actually char(1) */
 538    DBId_t ClientId;                   /* Id of client */
 539    DBId_t PoolId;                     /* Id of pool */
 540    DBId_t FileSetId;                  /* Id of FileSet */
 541    DBId_t PriorJobId;                 /* Id of migrated (prior) job */
 542    time_t SchedTime;                  /* Time job scheduled */
 543    time_t StartTime;                  /* Job start time */
 544    time_t EndTime;                    /* Job termination time of orig job */
 545    time_t RealEndTime;                /* Job termination time of this job */
 546    utime_t JobTDate;                  /* Backup time/date in seconds */
 547    uint32_t VolSessionId;
 548    uint32_t VolSessionTime;
 549    uint32_t JobFiles;
 550    uint32_t JobErrors;
 551    uint32_t JobMissingFiles;
 552    uint64_t JobBytes;
 553    int PurgedFiles;
 554    int HasBase;
 555
 556    /* Note, FirstIndex, LastIndex, Start/End File and Block
 557     * are only used in the JobMedia record.
 558     */
 559    uint32_t FirstIndex;               /* First index this Volume */
 560    uint32_t LastIndex;                /* Last index this Volume */
 561    uint32_t StartFile;
 562    uint32_t EndFile;
 563    uint32_t StartBlock;
 564    uint32_t EndBlock;
 565
 566    char cSchedTime[MAX_TIME_LENGTH];
 567    char cStartTime[MAX_TIME_LENGTH];
 568    char cEndTime[MAX_TIME_LENGTH];
 569    char cRealEndTime[MAX_TIME_LENGTH];
 570    /* Extra stuff not in DB */
 571    int limit;                         /* limit records to display */
 572    faddr_t rec_addr;
 573 };
 574
 575 /* Job Media information used to create the media records
 576  * for each Volume used for the job.
 577  */
 578 /* JobMedia record */
 579 struct JOBMEDIA_DBR {
 580    DBId_t JobMediaId;                 /* record id */
 581    JobId_t  JobId;                    /* JobId */
 582    DBId_t MediaId;                    /* MediaId */
 583    uint32_t FirstIndex;               /* First index this Volume */
 584    uint32_t LastIndex;                /* Last index this Volume */
 585    uint32_t StartFile;                /* File for start of data */
 586    uint32_t EndFile;                  /* End file on Volume */
 587    uint32_t StartBlock;               /* start block on tape */
 588    uint32_t EndBlock;                 /* last block */
 589    uint32_t Copy;                     /* identical copy */
 590 };
 591
 592
 593 /* Volume Parameter structure */
 594 struct VOL_PARAMS {
 595    char VolumeName[MAX_NAME_LENGTH];  /* Volume name */
 596    char MediaType[MAX_NAME_LENGTH];   /* Media Type */
 597    char Storage[MAX_NAME_LENGTH];     /* Storage name */
 598    uint32_t VolIndex;                 /* Volume seqence no. */
 599    uint32_t FirstIndex;               /* First index this Volume */
 600    uint32_t LastIndex;                /* Last index this Volume */
 601    uint32_t StartFile;                /* File for start of data */
 602    uint32_t EndFile;                  /* End file on Volume */
 603    uint32_t StartBlock;               /* start block on tape */
 604    uint32_t EndBlock;                 /* last block */
 605    int32_t Slot;                      /* Slot */
 606 // uint32_t Copy;                     /* identical copy */
 607 // uint32_t Stripe;                   /* RAIT strip number */
 608 };
 609
 610
 611 /* Attributes record -- NOT same as in database because
 612  *  in general, this "record" creates multiple database
 613  *  records (e.g. pathname, filename, fileattributes).
 614  */
 615 struct ATTR_DBR {
 616    char *fname;                       /* full path & filename */
 617    char *link;                        /* link if any */
 618    char *attr;                        /* attributes statp */
 619    uint32_t FileIndex;
 620    uint32_t Stream;
 621    JobId_t  JobId;
 622    DBId_t ClientId;
 623    DBId_t PathId;
 624    DBId_t FilenameId;
 625    FileId_t FileId;
 626    char *Digest;
 627    int DigestType;
 628 };
 629
 630
 631 /* File record -- same format as database */
 632 struct FILE_DBR {
 633    FileId_t FileId;
 634    uint32_t FileIndex;
 635    JobId_t  JobId;
 636    DBId_t FilenameId;
 637    DBId_t PathId;
 638    JobId_t  MarkId;
 639    char LStat[256];
 640    char Digest[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 641    int DigestType;                    /* NO_SIG/MD5_SIG/SHA1_SIG */
 642 };
 643
 644 /* Pool record -- same format as database */
 645 struct POOL_DBR {
 646    DBId_t PoolId;
 647    char Name[MAX_NAME_LENGTH];        /* Pool name */
 648    uint32_t NumVols;                  /* total number of volumes */
 649    uint32_t MaxVols;                  /* max allowed volumes */
 650    int32_t LabelType;                 /* Bacula/ANSI/IBM */
 651    int32_t UseOnce;                   /* set to use once only */
 652    int32_t UseCatalog;                /* set to use catalog */
 653    int32_t AcceptAnyVolume;           /* set to accept any volume sequence */
 654    int32_t AutoPrune;                 /* set to prune automatically */
 655    int32_t Recycle;                   /* default Vol recycle flag */
 656    utime_t  VolRetention;             /* retention period in seconds */
 657    utime_t  VolUseDuration;           /* time in secs volume can be used */
 658    uint32_t MaxVolJobs;               /* Max Jobs on Volume */
 659    uint32_t MaxVolFiles;              /* Max files on Volume */
 660    uint64_t MaxVolBytes;              /* Max bytes on Volume */
 661    char PoolType[MAX_NAME_LENGTH];
 662    char LabelFormat[MAX_NAME_LENGTH];
 663    /* Extra stuff not in DB */
 664    faddr_t rec_addr;
 665 };
 666
 667 class DEVICE_DBR {
 668 public:
 669    DBId_t DeviceId;
 670    char Name[MAX_NAME_LENGTH];        /* Device name */
 671    DBId_t MediaTypeId;                /* MediaType */
 672    DBId_t StorageId;                  /* Storage id if autochanger */
 673    uint32_t DevMounts;                /* Number of times mounted */
 674    uint32_t DevErrors;                /* Number of read/write errors */
 675    uint64_t DevReadBytes;             /* Number of bytes read */
 676    uint64_t DevWriteBytes;            /* Number of bytew written */
 677    uint64_t DevReadTime;              /* time spent reading volume */
 678    uint64_t DevWriteTime;             /* time spent writing volume */
 679    uint64_t DevReadTimeSincCleaning;  /* read time since cleaning */
 680    uint64_t DevWriteTimeSincCleaning; /* write time since cleaning */
 681    time_t   CleaningDate;             /* time last cleaned */
 682    utime_t  CleaningPeriod;           /* time between cleanings */
 683 };
 684
 685 class STORAGE_DBR {
 686 public:
 687    DBId_t StorageId;
 688    char Name[MAX_NAME_LENGTH];        /* Device name */
 689    int AutoChanger;                   /* Set if autochanger */
 690
 691    /* Not in database */
 692    bool created;                      /* set if created by db_create ... */
 693 };
 694
 695 class MEDIATYPE_DBR {
 696 public:
 697    DBId_t MediaTypeId;
 698    char MediaType[MAX_NAME_LENGTH];   /* MediaType string */
 699    int ReadOnly;                      /* Set if read-only */
 700 };
 701
 702
 703 /* Media record -- same as the database */
 704 struct MEDIA_DBR {
 705    DBId_t MediaId;                    /* Unique volume id */
 706    char VolumeName[MAX_NAME_LENGTH];  /* Volume name */
 707    char MediaType[MAX_NAME_LENGTH];   /* Media type */
 708    DBId_t PoolId;                     /* Pool id */
 709    time_t   FirstWritten;             /* Time Volume first written this usage */
 710    time_t   LastWritten;              /* Time Volume last written */
 711    time_t   LabelDate;                /* Date/Time Volume labeled */
 712    time_t   InitialWrite;             /* Date/Time Volume first written */
 713    int32_t  LabelType;                /* Label (Bacula/ANSI/IBM) */
 714    uint32_t VolJobs;                  /* number of jobs on this medium */
 715    uint32_t VolFiles;                 /* Number of files */
 716    uint32_t VolBlocks;                /* Number of blocks */
 717    uint32_t VolMounts;                /* Number of times mounted */
 718    uint32_t VolErrors;                /* Number of read/write errors */
 719    uint32_t VolWrites;                /* Number of writes */
 720    uint32_t VolReads;                 /* Number of reads */
 721    uint64_t VolBytes;                 /* Number of bytes written */
 722    uint32_t VolParts;                 /* Number of parts written */
 723    uint64_t MaxVolBytes;              /* Max bytes to write to Volume */
 724    uint64_t VolCapacityBytes;         /* capacity estimate */
 725    uint64_t VolReadTime;              /* time spent reading volume */
 726    uint64_t VolWriteTime;             /* time spent writing volume */
 727    utime_t  VolRetention;             /* Volume retention in seconds */
 728    utime_t  VolUseDuration;           /* time in secs volume can be used */
 729    uint32_t MaxVolJobs;               /* Max Jobs on Volume */
 730    uint32_t MaxVolFiles;              /* Max files on Volume */
 731    int32_t  Recycle;                  /* recycle yes/no */
 732    int32_t  Slot;                     /* slot in changer */
 733    int32_t  Enabled;                  /* 0=disabled, 1=enabled, 2=archived */
 734    int32_t  InChanger;                /* Volume currently in changer */
 735    DBId_t   StorageId;                /* Storage record Id */
 736    uint32_t EndFile;                  /* Last file on volume */
 737    uint32_t EndBlock;                 /* Last block on volume */
 738    uint32_t RecycleCount;             /* Number of times recycled */
 739    char     VolStatus[20];            /* Volume status */
 740    DBId_t   DeviceId;                 /* Device where Vol last written */
 741    DBId_t   LocationId;               /* Where Volume is -- user defined */
 742    DBId_t   ScratchPoolId;            /* Where to move if scratch */
 743    DBId_t   RecyclePoolId;            /* Where to move when recycled */
 744    /* Extra stuff not in DB */
 745    faddr_t rec_addr;                  /* found record address */
 746    /* Since the database returns times as strings, this is how we pass
 747     *   them back.
 748     */
 749    char    cFirstWritten[MAX_TIME_LENGTH]; /* FirstWritten returned from DB */
 750    char    cLastWritten[MAX_TIME_LENGTH];  /* LastWritten returned from DB */
 751    char    cLabelDate[MAX_TIME_LENGTH];    /* LabelData returned from DB */
 752    char    cInitialWrite[MAX_TIME_LENGTH]; /* InitialWrite returned from DB */
 753    bool    set_first_written;
 754    bool    set_label_date;
 755 };
 756
 757 /* Client record -- same as the database */
 758 struct CLIENT_DBR {
 759    DBId_t ClientId;                   /* Unique Client id */
 760    int AutoPrune;
 761    utime_t FileRetention;
 762    utime_t JobRetention;
 763    char Name[MAX_NAME_LENGTH];        /* Client name */
 764    char Uname[256];                   /* Uname for client */
 765 };
 766
 767 /* Counter record as in database */
 768 struct COUNTER_DBR {
 769    char Counter[MAX_NAME_LENGTH];
 770    int32_t MinValue;
 771    int32_t MaxValue;
 772    int32_t CurrentValue;
 773    char WrapCounter[MAX_NAME_LENGTH];
 774 };
 775
 776
 777 /* FileSet record -- same as the database */
 778 struct FILESET_DBR {
 779    DBId_t FileSetId;                  /* Unique FileSet id */
 780    char FileSet[MAX_NAME_LENGTH];     /* FileSet name */
 781    char MD5[50];                      /* MD5 signature of include/exclude */
 782    time_t CreateTime;                 /* date created */
 783    /*
 784     * This is where we return CreateTime
 785     */
 786    char cCreateTime[MAX_TIME_LENGTH]; /* CreateTime as returned from DB */
 787    /* Not in DB but returned by db_create_fileset() */
 788    bool created;                      /* set when record newly created */
 789 };
 790
 791 /* Call back context for getting a 32/64 bit value from the database */
 792 struct db_int64_ctx {
 793    int64_t value;                     /* value returned */
 794    int count;                         /* number of values seen */
 795 };
 796
 797
 798 #include "protos.h"
 799 #include "jcr.h"
 800 #include "sql_cmds.h"
 801
 802 /*
 803  * Some functions exported by sql.c for use within the
 804  *   cats directory.
 805  */
 806 void list_result(JCR *jcr, B_DB *mdb, DB_LIST_HANDLER *send, void *ctx, e_list_type type);
 807 void list_dashes(B_DB *mdb, DB_LIST_HANDLER *send, void *ctx);
 808 int get_sql_record_max(JCR *jcr, B_DB *mdb);
 809 bool check_tables_version(JCR *jcr, B_DB *mdb);
 810 void _db_unlock(const char *file, int line, B_DB *mdb);
 811 void _db_lock(const char *file, int line, B_DB *mdb);
 812 const char *db_get_type(void);
 813
 814 void print_dashes(B_DB *mdb);
 815 void print_result(B_DB *mdb);
 816 int QueryDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
 817 int InsertDB(const char *file, int line, JCR *jcr, B_DB *db, char *select_cmd);
 818 int DeleteDB(const char *file, int line, JCR *jcr, B_DB *db, char *delete_cmd);
 819 int UpdateDB(const char *file, int line, JCR *jcr, B_DB *db, char *update_cmd);
 820 void split_path_and_file(JCR *jcr, B_DB *mdb, const char *fname);
 821 #endif /* __SQL_H_ */