void PG_create_backend(struct DBdesc *db)
{
if (db->type == BE_TYPE_BACKUP) {
if (!config.sql_backup_host) return;
}
PG_compose_conn_string(db, config.sql_host);
}
int main(int argc, char **argv)
{
struct insert_data idata;
PGresult *ret;
FILE *f;
unsigned char fbuf[SRVBUFLEN];
char logfile[SRVBUFLEN];
char default_pwd[] = "arealsmartpwd";
int have_pwd = 0, have_logfile = 0, n;
int result = 0, position = 0, howmany = 0;
int do_nothing = 0;
char *cl_sql_host = NULL, *cl_sql_user = NULL, *cl_sql_db = NULL, *cl_sql_table = NULL;
char *sql_host;
struct template_entry *teptr;
int tot_size = 0, cnt = 0;
u_char *te;
struct template_header th;
struct db_cache data;
/* getopt() stuff */
extern char *optarg;
extern int optind, opterr, optopt;
int errflag = 0, cp;
memset(&idata, 0, sizeof(idata));
memset(sql_data, 0, sizeof(sql_data));
memset(update_clause, 0, sizeof(update_clause));
memset(insert_clause, 0, sizeof(insert_clause));
memset(lock_clause, 0, sizeof(lock_clause));
memset(where, 0, sizeof(where));
memset(values, 0, sizeof(values));
memset(&data, 0, sizeof(data));
memset(timebuf, 0, sizeof(timebuf));
pp_size = sizeof(struct db_cache);
while (!errflag && ((cp = getopt(argc, argv, ARGS)) != -1)) {
switch (cp) {
case 'd':
debug = TRUE;
break;
case 'f':
strlcpy(logfile, optarg, sizeof(logfile));
have_logfile = TRUE;
break;
case 'o':
position = atoi(optarg);
if (!position) {
printf("ERROR: invalid offset. Exiting.\n");
exit(1);
}
break;
case 'n':
howmany = atoi(optarg);
if (!howmany) {
printf("ERROR: invalid number of elements. Exiting.\n");
exit(1);
}
break;
case 't':
do_nothing = TRUE;
break;
case 'i':
sql_dont_try_update = TRUE;
break;
case 'e':
sql_history_since_epoch = TRUE;
break;
case 'P':
strlcpy(sql_pwd, optarg, sizeof(sql_pwd));
have_pwd = TRUE;
break;
case 'U':
cl_sql_user = malloc(SRVBUFLEN);
memset(cl_sql_user, 0, SRVBUFLEN);
strlcpy(cl_sql_user, optarg, SRVBUFLEN);
break;
case 'D':
cl_sql_db = malloc(SRVBUFLEN);
memset(cl_sql_db, 0, SRVBUFLEN);
strlcpy(cl_sql_db, optarg, SRVBUFLEN);
break;
case 'H':
cl_sql_host = malloc(SRVBUFLEN);
memset(cl_sql_host, 0, SRVBUFLEN);
strlcpy(cl_sql_host, optarg, SRVBUFLEN);
break;
case 'T':
cl_sql_table = malloc(SRVBUFLEN);
memset(cl_sql_table, 0, SRVBUFLEN);
strlcpy(cl_sql_table, optarg, SRVBUFLEN);
break;
case 'h':
usage(argv[0]);
exit(0);
break;
default:
usage(argv[0]);
exit(1);
}
}
/* searching for user supplied values */
if (!howmany) howmany = -1;
if (!have_pwd) memcpy(sql_pwd, default_pwd, sizeof(default_pwd));
if (!have_logfile) {
usage(argv[0]);
printf("\nERROR: missing logfile (-f)\nExiting...\n");
exit(1);
}
f = fopen(logfile, "r");
if (!f) {
printf("ERROR: %s does not exists\nExiting...\n", logfile);
exit(1);
}
fread(&lh, sizeof(lh), 1, f);
lh.sql_table_version = ntohs(lh.sql_table_version);
lh.sql_optimize_clauses = ntohs(lh.sql_optimize_clauses);
lh.sql_history = ntohs(lh.sql_history);
lh.what_to_count = ntohl(lh.what_to_count);
lh.magic = ntohl(lh.magic);
if (lh.magic == MAGIC) {
if (debug) printf("OK: Valid logfile header read.\n");
printf("sql_db: %s\n", lh.sql_db);
printf("sql_table: %s\n", lh.sql_table);
printf("sql_user: %s\n", lh.sql_user);
printf("sql_host: %s\n", lh.sql_host);
if (cl_sql_db||cl_sql_table||cl_sql_user||cl_sql_host)
printf("OK: Overrided by commandline options:\n");
if (cl_sql_db) printf("sql_db: %s\n", cl_sql_db);
if (cl_sql_table) printf("sql_table: %s\n", cl_sql_table);
if (cl_sql_user) printf("sql_user: %s\n", cl_sql_user);
if (cl_sql_host) printf("sql_host: %s\n", cl_sql_host);
}
else {
printf("ERROR: Invalid magic number. Exiting.\n");
exit(1);
}
/* binding SQL stuff */
if (cl_sql_db) sql_db = cl_sql_db;
else sql_db = lh.sql_db;
if (cl_sql_table) sql_table = cl_sql_table;
else sql_table = lh.sql_table;
if (cl_sql_user) sql_user = cl_sql_user;
else sql_user = lh.sql_user;
if (cl_sql_host) sql_host = cl_sql_host;
else sql_host = lh.sql_host;
fread(&th, sizeof(th), 1, f);
th.magic = ntohl(th.magic);
th.num = ntohs(th.num);
th.sz = ntohs(th.sz);
if (th.magic == TH_MAGIC) {
if (debug) printf("OK: Valid template header read.\n");
if (th.num > N_PRIMITIVES) {
printf("ERROR: maximum number of primitives exceeded. Exiting.\n");
exit(1);
}
te = malloc(th.num*sizeof(struct template_entry));
memset(te, 0, th.num*sizeof(struct template_entry));
fread(te, th.num*sizeof(struct template_entry), 1, f);
}
else {
if (debug) printf("ERROR: no template header found.\n");
exit(1);
}
/* checking template */
if (th.sz >= sizeof(fbuf)) {
printf("ERROR: Objects are too big. Exiting.\n");
exit(1);
}
teptr = (struct template_entry *) te;
for (tot_size = 0, cnt = 0; cnt < th.num; cnt++, teptr++)
tot_size += teptr->size;
if (tot_size != th.sz) {
printf("ERROR: malformed template header. Size mismatch. Exiting.\n");
exit(1);
}
TPL_check_sizes(&th, &data, te);
if (!do_nothing) {
PG_compose_conn_string(&p, sql_host);
if (!PG_DB_Connect2(&p)) {
printf("ALERT: PG_DB_Connect2(): PGSQL daemon failed.\n");
exit(1);
}
}
else {
if (debug) print_header();
}
/* composing the proper (filled with primitives used during
the current execution) SQL strings */
idata.num_primitives = PG_compose_static_queries();
idata.now = time(NULL);
/* handling offset */
if (position) n = fseek(f, (th.sz*position), SEEK_CUR);
/* handling single or iterative request */
if (!do_nothing) ret = PQexec(p.desc, lock_clause);
while(!feof(f)) {
if (!howmany) break;
else if (howmany > 0) howmany--;
memset(fbuf, 0, th.sz);
n = fread(fbuf, th.sz, 1, f);
if (n) {
re++;
TPL_pop(fbuf, &data, &th, te);
if (!do_nothing) result = PG_cache_dbop(&p, &data, &idata);
else {
if (debug) print_data(&data, lh.what_to_count, (position+re));
}
if (!result) we++;
if (re != we) printf("WARN: unable to write element %u.\n", re);
}
}
if (!do_nothing) {
ret = PQexec(p.desc, "COMMIT");
if (PQresultStatus(ret) != PGRES_COMMAND_OK) {
we = 0; /* if we fail to commit, no elements will be written */
PQclear(ret);
}
printf("\nOK: written [%u/%u] elements.\n", we, re);
}
else printf("OK: read [%u] elements.\n", re);
PQfinish(p.desc);
fclose(f);
return 0;
}