profesor *consultar_docente(long docente_id) {
profesor *p = NULL;
char sql[512];
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
if (docente_id > 0) {
p = (profesor *) malloc(sizeof (profesor));
p->docente_id = docente_id;
p->aprobacion = 0.0;
p->promedio = 0.0;
p->reprobacion = 0.0;
p->stddev = 0.0;
// Busco Reprobados
memset(sql, 0, sizeof (sql));
sprintf(sql, "SELECT AVG(asignaturas_cursadas.nota) FROM cursos INNER JOIN asignaturas_cursadas ON cursos.curso_id=asignaturas_cursadas.curso_id WHERE cursos.docente_id = '%ld' AND asignaturas_cursadas.nota < 4 GROUP BY cursos.docente_id", docente_id);
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
p->reprobacion = getDouble(dbresult(resultado, 0, 0));
dbfree(resultado);
}
dbclose(conexion);
}
// Busco Aprobados
memset(sql, 0, sizeof (sql));
sprintf(sql, "SELECT AVG(asignaturas_cursadas.nota) FROM cursos INNER JOIN asignaturas_cursadas ON cursos.curso_id=asignaturas_cursadas.curso_id WHERE cursos.docente_id = '%ld' AND asignaturas_cursadas.nota >= 4 GROUP BY cursos.docente_id", docente_id);
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
p->aprobacion = getDouble(dbresult(resultado, 0, 0));
dbfree(resultado);
}
dbclose(conexion);
}
// Busco Promedio
memset(sql, 0, sizeof (sql));
sprintf(sql, "SELECT AVG(asignaturas_cursadas.nota) AS promedio, STDDEV(asignaturas_cursadas.nota) FROM cursos INNER JOIN asignaturas_cursadas ON cursos.curso_id=asignaturas_cursadas.curso_id WHERE cursos.docente_id = '%ld' GROUP BY cursos.docente_id ORDER BY promedio DESC", docente_id);
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
p->promedio = getDouble(dbresult(resultado, 0, 0));
p->stddev = getDouble(dbresult(resultado, 0, 1));
dbfree(resultado);
}
dbclose(conexion);
}
}
return p;
}
ranking_profesor *ranking_docentes(int semestre, int anio, long *tamano) {
ranking_profesor *ranking = NULL;
char sql[512];
int i = 0;
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
if (semestre > 0 && anio > 0) {
memset(sql, 0, sizeof (sql));
sprintf(sql, "SELECT cursos.docente_id, AVG(asignaturas_cursadas.nota) AS promedio, STDDEV(asignaturas_cursadas.nota) FROM cursos INNER JOIN asignaturas_cursadas ON cursos.curso_id=asignaturas_cursadas.curso_id WHERE cursos.semestre='%d' AND cursos.anio='%d' GROUP BY cursos.docente_id ORDER BY promedio DESC", semestre, anio);
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
ranking = (ranking_profesor *) malloc(num * sizeof (ranking_profesor));
for (i = 0; i < num; i++) {
ranking[i].lugar = i + 1;
ranking[i].docente_id = getLong(dbresult(resultado, i, 0));
ranking[i].nota = getDouble(dbresult(resultado, i, 1));
ranking[i].stddev = getDouble(dbresult(resultado, i, 2));
ranking[i].semestre = semestre;
ranking[i].anio = anio;
}
dbfree(resultado);
}
dbclose(conexion);
}
}
*tamano = num;
return ranking;
}
ventas_anuales* getVentasAnuales(int* cantidades_ventas) {
ventas_anuales* ventas = NULL;
int i = 0;
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, "SELECT tienda, SUM(monto) FROM ventas GROUP BY tienda");
num = dbnumrows(resultado);
if (num > 0) {
ventas = (ventas_anuales *) malloc(num * sizeof (ventas_anuales));
for (i = 0; i < num; i++) {
ventas[i].tienda = getString(dbresult(resultado, i, 0));
ventas[i].monto = getLong(dbresult(resultado, i, 1));
}
dbfree(resultado);
}
dbclose(conexion);
}
*cantidades_ventas = num;
return ventas;
}
void
usage(void)
{
g_fprintf(stderr, _("Usage: amfetchdump [options] [-o configoption]* config hostname [diskname [datestamp [level [hostname [diskname [datestamp [level ... ]]]]]]]\n\n"));
g_fprintf(stderr, _("Goes and grabs a dump from tape, moving tapes around and assembling parts as\n"));
g_fprintf(stderr, _("necessary. Files are restored to the current directory, unless otherwise\nspecified.\n\n"));
g_fprintf(stderr, _(" -p Pipe exactly *one* complete dumpfile to stdout, instead of to disk.\n"));
g_fprintf(stderr, _(" -h Output the amanda header to same output as the image.\n"));
g_fprintf(stderr, _(" --header-fd <fd> Output the amanda header to the numbered file descriptor.\n"));
g_fprintf(stderr, _(" --header-file <filename> Output the amanda header to the filename.\n"));
g_fprintf(stderr, _(" -O <output dir> Restore files to this directory.\n"));
g_fprintf(stderr, _(" -d <device> Force restoration from a particular tape device.\n"));
g_fprintf(stderr, _(" -c Compress output, fastest method available.\n"));
g_fprintf(stderr, _(" -C Compress output, best filesize method available.\n"));
g_fprintf(stderr, _(" -l Leave dumps (un)compressed, whichever way they were originally on tape.\n"));
g_fprintf(stderr, _(" -a Assume all tapes are available via changer, do not prompt for initial load.\n"));
g_fprintf(stderr, _(" -i <dst_file> Search through tapes and write out an inventory while we\n restore. Useful only if normal logs are unavailable.\n"));
g_fprintf(stderr, _(" -w Wait to put split dumps together until all chunks have been restored.\n"));
g_fprintf(stderr, _(" -n Do not reassemble split dumpfiles.\n"));
g_fprintf(stderr, _(" -k Skip the rewind/label read when reading a new tape.\n"));
g_fprintf(stderr, _(" -s Do not use fast forward to skip files we won't restore. Use only if fsf\n causes your tapes to skip too far.\n"));
g_fprintf(stderr, _(" -b <blocksize> Force a particular block size (default is 32kb).\n"));
dbclose();
exit(1);
}
ventas_horarias* getVentasHorarias(int* cantidades_ventas) {
ventas_horarias* ventas = NULL;
int i = 0;
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, "SELECT DISTINCT ON (tienda) tienda, EXTRACT(hour FROM fecha) AS hora,SUM(monto) AS total FROM ventas GROUP BY tienda, hora ORDER BY tienda, SUM(monto) DESC");
num = dbnumrows(resultado);
if (num > 0) {
ventas = (ventas_horarias *) malloc(num * sizeof (ventas_horarias));
for (i = 0; i < num; i++) {
ventas[i].tienda = getString(dbresult(resultado, i, 0));
ventas[i].hora = getInt(dbresult(resultado, i, 1));
ventas[i].monto = getLong(dbresult(resultado, i, 2));
}
dbfree(resultado);
}
dbclose(conexion);
}
*cantidades_ventas = num;
return ventas;
}
int save_pid_to_db(int id,char* pd)
{
char szUsername[32] = "sa";
char szPassword[32]= "1qazxsw2*";
char szDBName[32] = "ids_db";
char szServer[32] = "10.2.10.201";
char sqlquery[1024]={0};
snprintf(sqlquery,1024,"update ids_policy_event set pid='%s' where id='%d'",pd,id);
dbinit();
LOGINREC *loginrec = dblogin();
DBSETLUSER(loginrec, szUsername);
DBSETLPWD(loginrec, szPassword);
DBPROCESS *dbprocess = dbopen(loginrec, szServer);
if(dbprocess == FAIL)
{
LOG_INFO(" Conect MS SQL SERVER fail ");
return -1;
}
if(dbuse(dbprocess, szDBName) == FAIL)
{
LOG_INFO(" Open database name fail");
return -1;
}
dbcmd(dbprocess,sqlquery);
if(dbsqlexec(dbprocess) == FAIL)
{
LOG_INFO("task.cpp dbsqlexec error!!!");
}
dbclose(dbprocess);
return 0;
}
// one arg - logout
static v8::Handle<Value> Logout(const Arguments& args) {
v8::HandleScope scope;
REQ_DBCONN_ARG(0);
dbfreebuf(dbconn);
dbclose(dbconn);
return v8::Undefined();
}
pascal boolean odbNewFile (hdlfilenum fnum) {
/*
4.1b5 dmb: new routine. minimal db creation. does not leave it open
*/
tyversion2cancoonrecord info;
dbaddress adr = nildbaddress;
boolean fl;
setemptystring (bserror);
if (!dbnew (fnum))
return (false);
clearbytes (&info, sizeof (info));
info.versionnumber = conditionalshortswap (cancoonversionnumber);
fl = dbassign (&adr, sizeof (info), &info);
if (fl) {
dbsetview (cancoonview, adr);
dbclose ();
}
cancoonglobals = nil; /*if they've been set, they're out of date*/
dbdispose ();
return (fl);
} /*odbNewFile*/
ventas_mensuales* getVentasMensuales(char* tienda, int* cantidades_ventas) {
ventas_mensuales* ventas = NULL;
int i = 0;
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
char sql[513];
if (tienda != NULL) {
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
memset(sql, 0, sizeof (sql));
snprintf(sql, 512, "SELECT tienda, EXTRACT(month FROM fecha) AS mes,SUM(monto) AS total FROM ventas WHERE tienda = '%s' GROUP BY tienda, mes ORDER BY mes", tienda);
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
ventas = (ventas_mensuales *) malloc(num * sizeof (ventas_mensuales));
for (i = 0; i < num; i++) {
ventas[i].tienda = getString(dbresult(resultado, i, 0));
ventas[i].mes = getInt(dbresult(resultado, i, 1));
ventas[i].monto = getLong(dbresult(resultado, i, 2));
}
dbfree(resultado);
}
dbclose(conexion);
}
}
*cantidades_ventas = num;
return ventas;
}
int Thread_Exit(int id)
{
if (Conexion[id].nAbierta)
//PQfinish(Conexion[id].dbconn);//Descomentar cuando este implementado
dbfreebuf(Conexion[id].dbconn);
dbclose(Conexion[id].dbconn);
dbexit();
}
QTDSResult::~QTDSResult()
{
cleanup();
if (d->dbproc)
dbclose(d->dbproc);
errs()->remove(d->dbproc);
delete d;
}
int syb_terminate_order (int no_des)
{
if (descriptor[no_des] != NULL && no_des != PRIVATE_DESCRIPTOR)
{
dbclose (descriptor[no_des]);
descriptor[no_des] = NULL;
}
return 0;
}
static VALUE rb_tinytds_close(VALUE self) {
GET_CLIENT_WRAPPER(self);
if (cwrap->client && !cwrap->closed) {
dbclose(cwrap->client);
cwrap->closed = 1;
cwrap->userdata->closed = 1;
}
return Qtrue;
}
Connector::~Connector()
{
#ifdef MSSQL
dbclose(conn_ptr);
dbloginfree(login_rec);
#elif WATCHLIST_MYSQL
mysql_close(&mysqlID);
#endif
}
/*************************************************************************
*
* Function: sql_close
*
* Purpose: database specific close. Closes an open database
* connection
*
*************************************************************************/
static int sql_close(SQLSOCK *sqlsocket, UNUSED SQL_CONFIG *config)
{
rlm_sql_freetds_sock *freetds_sock = sqlsocket->conn;
if (freetds_sock && freetds_sock->dbproc){
dbclose(freetds_sock->dbproc);
freetds_sock->dbproc = NULL;
}
return 0;
}
void dealloc()
{
# ifdef _FREETDS
if (proc)
dbclose(proc);
# endif
# ifdef _MSSQL
::CoUninitialize();
# endif
}
int
main(int argc, char *argv[])
{
LOGINREC *login;
DBPROCESS *dbproc;
int ret_code;
int num_cols;
int num_res;
set_malloc_options();
read_login_info(argc, argv);
printf("Starting %s\n", argv[0]);
dbinit();
dberrhandle(syb_err_handler);
dbmsghandle(syb_msg_handler);
printf("About to logon\n");
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "t0012");
dbproc = dbopen(login, SERVER);
if (strlen(DATABASE)) {
dbuse(dbproc, DATABASE);
}
dbloginfree(login);
printf("After logon\n");
/* select */
sql_cmd(dbproc);
dbsqlexec(dbproc);
num_res = 0;
while ((ret_code = dbresults(dbproc)) == SUCCEED) {
num_cols = dbnumcols(dbproc);
printf("Result %d has %d columns\n", num_res, num_cols);
if (!(num_res % 2) && num_cols)
set_failed();
while(dbnextrow(dbproc) != NO_MORE_ROWS) {};
num_res++;
}
if (ret_code == FAIL)
set_failed();
dbclose(dbproc);
dbexit();
printf("%s %s\n", __FILE__, (failed ? "failed!" : "OK"));
return failed ? 1 : 0;
}
static void rb_tinytds_client_free(void *ptr) {
tinytds_client_wrapper *cwrap = (tinytds_client_wrapper *)ptr;
if (cwrap->login)
dbloginfree(cwrap->login);
if (cwrap->client && !cwrap->closed) {
dbclose(cwrap->client);
cwrap->closed = 1;
cwrap->userdata->closed = 1;
}
xfree(cwrap->userdata);
xfree(ptr);
}
int
main(int argc, char **argv)
{
BCPPARAMDATA params;
DBPROCESS *dbsrc;
DBPROCESS *dbtarget;
setlocale(LC_ALL, "");
memset(¶ms, '\0', sizeof(params));
if (process_parameters(argc, argv, ¶ms) == FALSE) {
pusage();
return 1;
}
if (login_to_databases(¶ms, &dbsrc, &dbtarget) == FALSE)
return 1;
if (params.cflag) {
if (create_target_table(params.src.dbobject, params.owner, params.dest.dbobject, dbsrc, dbtarget) == FALSE) {
printf("datacopy: could not create target table %s.%s . terminating\n", params.owner, params.dest.dbobject);
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
}
if (check_table_structures(params.src.dbobject, params.dest.dbobject, dbsrc, dbtarget) == FALSE) {
printf("datacopy: table structures do not match. terminating\n");
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
if (transfer_data(params, dbsrc, dbtarget) == FALSE) {
printf("datacopy: table copy failed.\n");
printf(" the data may have been partially copied into the target database \n");
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
dbclose(dbsrc);
dbclose(dbtarget);
return 0;
}
static apr_status_t dbd_freetds_check_conn(apr_pool_t *pool,
apr_dbd_t *handle)
{
if (dbdead(handle->proc)) {
/* try again */
dbclose(handle->proc);
handle->proc = freetds_open(handle->pool, handle->params, NULL);
if (!handle->proc || dbdead(handle->proc)) {
return APR_EGENERAL;
}
}
/* clear it, in case this is called in error handling */
dbcancel(handle->proc);
return APR_SUCCESS;
}
static void
ngx_dbd_freetds_close(ngx_dbd_t *dbd)
{
RETCODE rc;
ngx_dbd_freetds_ctx_t *ctx;
ngx_log_debug0(NGX_LOG_DEBUG_MYSQL, dbd->log, 0, "dbd freetds close");
ctx = dbd->ctx;
rc = dbcanquery(ctx->db);
/* TODO: rc */
dbclose(ctx->db);
}
static void *
thread_test(void * arg)
{
int i;
int num = ptr2int(arg);
DBPROCESS *dbproc;
LOGINREC *login;
login = dblogin();
DBSETLPWD(login, PASSWORD);
DBSETLUSER(login, USER);
DBSETLAPP(login, "thread");
dbproc = dbopen(login, SERVER);
if (!dbproc) {
dbloginfree(login);
fprintf(stderr, "Unable to connect to %s\n", SERVER);
set_failed();
return NULL;
}
dbloginfree(login);
if (strlen(DATABASE))
dbuse(dbproc, DATABASE);
pthread_mutex_lock(&mutex);
++thread_count;
pthread_mutex_unlock(&mutex);
printf("thread %2d waiting for all threads to start\n", num+1);
pthread_mutex_lock(&mutex);
while (thread_count < NUM_THREAD) {
pthread_mutex_unlock(&mutex);
sleep(1);
pthread_mutex_lock(&mutex);
}
pthread_mutex_unlock(&mutex);
for (i = 1; i <= NUM_LOOP; ++i) {
printf("thread %2d of %2d loop %d\n", num+1, NUM_THREAD, i);
if (test(dbproc) || result != 0)
break;
}
dbclose(dbproc);
return NULL;
}
void SqlServer::close()
{
# ifdef _FREETDS
if (d_ptr->proc)
{
dbclose(d_ptr->proc);
d_ptr->proc = NULL;
}
# endif
# ifdef _MSSQL
if (d_ptr->conn && d_ptr->conn->State == adStateOpen)
{
d_ptr->conn->Close();
}
# endif
}
static int dblib_handle_closer(pdo_dbh_t *dbh)
{
pdo_dblib_db_handle *H = (pdo_dblib_db_handle *)dbh->driver_data;
if (H) {
if (H->link) {
dbclose(H->link);
H->link = NULL;
}
if (H->login) {
dbfreelogin(H->login);
H->login = NULL;
}
pefree(H, dbh->is_persistent);
dbh->driver_data = NULL;
}
return 0;
}
bool QTDSDriver::open(const QString & db,
const QString & user,
const QString & password,
const QString & host,
int /*port*/,
const QString& /*connOpts*/)
{
if (isOpen())
close();
if (!dbinit()) {
setOpenError(true);
return false;
}
d->login = dblogin();
if (!d->login) {
setOpenError(true);
return false;
}
DBSETLPWD(d->login, const_cast<char*>(password.toLocal8Bit().constData()));
DBSETLUSER(d->login, const_cast<char*>(user.toLocal8Bit().constData()));
// Now, try to open and use the database. If this fails, return false.
DBPROCESS* dbproc;
dbproc = dbopen(d->login, const_cast<char*>(host.toLatin1().constData()));
if (!dbproc) {
setLastError(qMakeError(tr("Unable to open connection"), QSqlError::ConnectionError, -1));
setOpenError(true);
return false;
}
if (dbuse(dbproc, const_cast<char*>(db.toLatin1().constData())) == FAIL) {
setLastError(qMakeError(tr("Unable to use database"), QSqlError::ConnectionError, -1));
setOpenError(true);
return false;
}
dbclose( dbproc );
setOpen(true);
setOpenError(false);
d->hostName = host;
d->db = db;
return true;
}
alumno_ramo *consultar_notas_por_estudiante(long estudiante_id, long *tamano) {
alumno_ramo *arreglo = NULL;
char sql[512];
char asignatura[128];
int i = 0;
int num = 0;
PGconn *conexion = NULL;
PGresult *resultado = NULL;
if (estudiante_id > 0) {
memset(sql, 0, sizeof (sql));
sprintf(sql, "SELECT cursos.asignatura, asignaturas_cursadas.nota FROM cursos INNER JOIN asignaturas_cursadas ON cursos.curso_id=asignaturas_cursadas.curso_id WHERE estudiante_id='%ld' ORDER BY cursos.anio ASC, cursos.semestre ASC", estudiante_id);
conexion = dbconnect(SERVIDOR, PUERTO, NOMBREDB, USUARIODB, PASSDB);
if (conexion != NULL) {
resultado = dbquery(conexion, sql);
num = dbnumrows(resultado);
if (num > 0) {
arreglo = (alumno_ramo *) malloc(num * sizeof (alumno_ramo));
for (i = 0; i < num; i++) {
memset(asignatura, 0, sizeof (asignatura));
sprintf(asignatura, "%s", getString(dbresult(resultado, i, 0)));
arreglo[i].asignatura = (char *) calloc(strlen(asignatura) + 1, sizeof (char));
sprintf(arreglo[i].asignatura, "%s", asignatura);
arreglo[i].estudiante_id = estudiante_id;
arreglo[i].nota = getDouble(dbresult(resultado, i, 1));
arreglo[i].stddev = 0.0;
}
dbfree(resultado);
}
dbclose(conexion);
}
}
*tamano = (long) num;
return arreglo;
}
bool CDBL_Connection::Close(void)
{
if (GetDBLibConnection()) {
Refresh();
// Clean user data ...
dbsetuserdata(GetDBLibConnection(), (BYTE*) NULL);
dbclose(GetDBLibConnection());
CheckFunctCall();
MarkClosed();
dbloginfree(m_Login);
CheckFunctCall();
m_Link = NULL;
return true;
}
return false;
}
int
main(
int argc,
char ** argv)
{
int i;
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
set_pname("infofile");
dbopen(DBG_SUBDIR_SERVER);
for(i = 1; i < argc; ++i) {
if(i+1 >= argc) {
g_fprintf(stderr,_("usage: %s host disk [host disk ...]\n"),argv[0]);
return 1;
}
open_infofile("curinfo");
dump_db(argv[i], argv[i+1]);
i++;
close_infofile();
}
dbclose();
return 0;
}
int
main(
int argc,
char ** argv)
{
#ifdef GNUTAR
int i;
char *e;
char *dbf;
char *cmdline;
GPtrArray *array = g_ptr_array_new();
gchar **strings;
char **new_argv;
#endif
if (argc > 1 && argv[1] && g_str_equal(argv[1], "--version")) {
printf("runtar-%s\n", VERSION);
return (0);
}
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
safe_cd();
set_pname("runtar");
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
dbopen(DBG_SUBDIR_CLIENT);
config_init(CONFIG_INIT_CLIENT, NULL);
if (argc < 3) {
error(_("Need at least 3 arguments\n"));
/*NOTREACHED*/
}
dbprintf(_("version %s\n"), VERSION);
if (!g_str_equal(argv[3], "--create")) {
error(_("Can only be used to create tar archives\n"));
/*NOTREACHED*/
}
#ifndef GNUTAR
g_fprintf(stderr,_("gnutar not available on this system.\n"));
dbprintf(_("%s: gnutar not available on this system.\n"), argv[0]);
dbclose();
return 1;
#else
/*
* Print out version information for tar.
*/
do {
FILE * version_file;
char version_buf[80];
if ((version_file = popen(GNUTAR " --version 2>&1", "r")) != NULL) {
if (fgets(version_buf, (int)sizeof(version_buf), version_file) != NULL) {
dbprintf(_(GNUTAR " version: %s\n"), version_buf);
} else {
if (ferror(version_file)) {
dbprintf(_(GNUTAR " version: Read failure: %s\n"), strerror(errno));
} else {
dbprintf(_(GNUTAR " version: Read failure; EOF\n"));
}
}
} else {
dbprintf(_(GNUTAR " version: unavailable: %s\n"), strerror(errno));
}
} while(0);
#ifdef WANT_SETUID_CLIENT
check_running_as(RUNNING_AS_CLIENT_LOGIN | RUNNING_AS_UID_ONLY);
if (!become_root()) {
error(_("error [%s could not become root (is the setuid bit set?)]\n"), get_pname());
/*NOTREACHED*/
}
#else
check_running_as(RUNNING_AS_CLIENT_LOGIN);
#endif
/* skip argv[0] */
argc--;
argv++;
dbprintf(_("config: %s\n"), argv[0]);
if (!g_str_equal(argv[0], "NOCONFIG"))
dbrename(argv[0], DBG_SUBDIR_CLIENT);
argc--;
argv++;
new_argv = g_new0(char *, argc+1);
new_argv[0] = g_strdup_printf("%s", argv[0]);
g_ptr_array_add(array, g_strdup(GNUTAR));
for (i = 1; argv[i]; i++) {
g_ptr_array_add(array, quote_string(argv[i]));
new_argv[i] = g_strdup_printf("%s", argv[i]);
}
g_ptr_array_add(array, NULL);
strings = (gchar **)g_ptr_array_free(array, FALSE);
cmdline = g_strjoinv(" ", strings);
g_strfreev(strings);
dbprintf(_("running: %s\n"), cmdline);
amfree(cmdline);
dbf = dbfn();
if (dbf) {
dbf = g_strdup(dbf);
}
dbclose();
execve(GNUTAR, new_argv, safe_env());
e = strerror(errno);
dbreopen(dbf, "more");
amfree(dbf);
dbprintf(_("execve of %s failed (%s)\n"), GNUTAR, e);
dbclose();
g_fprintf(stderr, _("runtar: could not exec %s: %s\n"), GNUTAR, e);
return 1;
#endif
}
int
main (int argc, char **argv)
{
int c,
verbose = 0,
errflg = 0;
char *dbinname=malloc(1024);
char *dboutname=malloc(1024);
Point *poly;
double lat,lon;
char *subset_expr=NULL;
char *name=malloc(100);
long nregions, nvertices;
Tbl *sortkeys;
Dbptr dbin,dbout,dbi,dbo,dbs;
long i,from,to,nv;
long vertex;
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "s:vV")) != -1) {
switch (c) {
case 's':
subset_expr=optarg;
break;
case 'v':
verbose++ ;
break;
case 'V':
usage ();
break;
case '?':
errflg++;
break ;
}
}
if ((errflg) || argc < 3)
usage ();
dbinname = argv[optind++];
dboutname= argv[optind++];
if (dbopen(dbinname,"r",&dbin)) {
elog_die(1,"cannot open database %s",dbinname);
}
dbi=dblookup(dbin,0,"polygon",0,0);
if (subset_expr) {
dbi=dbsubset(dbi,subset_expr,NULL);
}
sortkeys=newtbl(1);
pushtbl(sortkeys,"pname");
dbs=dbsort(dbi,sortkeys,0,"sorted");
dbquery(dbs,dbRECORD_COUNT,&nregions);
if (nregions <1) {
elog_die(0,"table regions seems to be empty (or not present)");
}
if (verbose) elog_notify(0,"creating database descriptor %s",dboutname);
if (dbcreate(dboutname,"places1.2",0,0,0)) {
elog_die(1,"cannot create database %s",dboutname);
}
dbopen(dboutname,"r+",&dbout);
dbo=dblookup(dbout,0,"regions",0,0);
for (i=0; i< nregions; i++) {
dbs.record=i;
dbgetv(dbs,0,"pname",name,NULL );
nvertices=readPolygon(dbs,&poly);
for (nv=0;nv < nvertices;nv++) {
lat=poly[nv].lat;
lon=poly[nv].lon;
dbaddv(dbo,0,
"regname",name,
"vertex",nv,
"lat",lat,"lon",lon,
NULL );
}
free(poly);
}
dbclose(dbo);
/*
*/
return 0;
}
