static void clean_exit(int sig)
{
ipc_deinit();
sql_close();
net_deinit();
daemon_shutdown();
_exit(!!sig);
}
CDbxSQLite::~CDbxSQLite()
{
sql_close(m_sqlite);
for (int i = 0; i < sql_prepare_len; i++)
sql_finalize(*sql_prepare_stmt[i]);
mir_free(sql_prepare_text);
mir_free(sql_prepare_stmt);
DestroyWindow(m_hAPCWindow);
}
void
sql_closeFree(int cid)
{
const short *exc = exclist;
sql_close(cid);
if(!rv_lastStatus) {
exclist = exc;
sql_free(cid);
}
} /* sql_closeFree */
/*************************************************************************
*
* Function: sql_create_socket
*
* Purpose: Establish connection to the db
*
*************************************************************************/
static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
char connstring[2048];
const char *port, *host;
rlm_sql_postgres_sock *pg_sock;
#ifdef HAVE_OPENSSL_CRYPTO_H
static int ssl_init = 0;
if (!ssl_init) {
PQinitSSL(0);
ssl_init = 1;
}
#endif
if (config->sql_server[0] != '\0') {
host = " host=";
} else {
host = "";
}
if (config->sql_port[0] != '\0') {
port = " port=";
} else {
port = "";
}
if (!sqlsocket->conn) {
sqlsocket->conn = (rlm_sql_postgres_sock *)rad_malloc(sizeof(rlm_sql_postgres_sock));
if (!sqlsocket->conn) {
return -1;
}
}
pg_sock = sqlsocket->conn;
memset(pg_sock, 0, sizeof(*pg_sock));
snprintf(connstring, sizeof(connstring),
"dbname=%s%s%s%s%s user=%s password=%s",
config->sql_db, host, config->sql_server,
port, config->sql_port,
config->sql_login, config->sql_password);
pg_sock->row=NULL;
pg_sock->result=NULL;
pg_sock->conn=PQconnectdb(connstring);
if (PQstatus(pg_sock->conn) != CONNECTION_OK) {
radlog(L_ERR, "rlm_sql_postgresql: Couldn't connect socket to PostgreSQL server %s@%s:%s", config->sql_login, config->sql_server, config->sql_db);
/*radlog(L_ERR, "rlm_sql_postgresql: Postgresql error '%s'", PQerrorMessage(pg_sock->conn));*/
sql_close(sqlsocket, config);
return SQL_DOWN;
}
return 0;
}
/*************************************************************************
*
* Function: sql_init_socket
*
* Purpose: Establish connection to the db
*
*************************************************************************/
static int sql_init_socket(SQLSOCK *sqlsocket, SQL_CONFIG *config) {
rlm_sql_oracle_sock *oracle_sock;
if (!sqlsocket->conn) {
sqlsocket->conn = (rlm_sql_oracle_sock *)rad_malloc(sizeof(rlm_sql_oracle_sock));
if (!sqlsocket->conn) {
return -1;
}
}
memset(sqlsocket->conn,0,sizeof(rlm_sql_oracle_sock));
oracle_sock = sqlsocket->conn;
if (OCIEnvCreate(&oracle_sock->env, OCI_DEFAULT|OCI_THREADED, (dvoid *)0,
(dvoid * (*)(dvoid *, size_t)) 0,
(dvoid * (*)(dvoid *, dvoid *, size_t))0,
(void (*)(dvoid *, dvoid *)) 0,
0, (dvoid **)0 )) {
radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle OCI environment (OCIEnvCreate())");
return -1;
}
if (OCIHandleAlloc((dvoid *) oracle_sock->env, (dvoid **) &oracle_sock->errHandle,
(ub4) OCI_HTYPE_ERROR, (size_t) 0, (dvoid **) 0))
{
radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle ERROR handle (OCIHandleAlloc())");
return -1;
}
/* Allocate handles for select and update queries */
if (OCIHandleAlloc((dvoid *)oracle_sock->env, (dvoid **) &oracle_sock->queryHandle,
(ub4)OCI_HTYPE_STMT, (CONST size_t) 0, (dvoid **) 0))
{
radlog(L_ERR,"rlm_sql_oracle: Couldn't init Oracle query handles: %s",
sql_error(sqlsocket, config));
return -1;
}
if (OCILogon(oracle_sock->env, oracle_sock->errHandle, &oracle_sock->conn,
config->sql_login, strlen(config->sql_login),
config->sql_password, strlen(config->sql_password),
config->sql_db, strlen(config->sql_db)))
{
radlog(L_ERR,"rlm_sql_oracle: Oracle logon failed: '%s'", sql_error(sqlsocket, config));
sql_close(sqlsocket,config);
return -1;
}
return 0;
}
bool sql_run(const char *stmt, SQL_ROW &argv) {
SQL_CURSOR fd;
bool ret=true;
fd = sql_open(stmt, argv);
if (ret=chk_cursor(fd, stmt)) {
if (cursor_arr[fd].is_select) {
ret=sql_fetch(fd);
if (ret) {
argv=sql_values(fd);
} else {
ret=chk_cursor(fd, stmt);
}
}
}
if (fd>=0) sql_close(fd);
return ret;
}
bool sql_exists(const char *table, const char *field, const char *value,
const char *where) {
char stmt[sql::MAX_QUERY_LEN];
SQL_CURSOR c;
int rv=false;
if (value && *value) {
sprintf(stmt,"select '1' from %s where %s = %s", table, field, value);
} else {
sprintf(stmt,"select '1' from %s",table);
if (where && *where) {
sprintf(stmt+strlen(stmt),"where %s",where);
}
}
if (((c=sql_open(stmt))>=0) && sql_fetch(c)) {
rv=true;
}
sql_close(c);
return rv;
}
void
sql_free(int cid)
{
struct OCURS *o = findCursor(cid);
if(o->flag == CURSOR_OPENED)
sql_close(cid);
stmt_text = "free";
debugStatement();
hstmt = o->hstmt;
rc = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
o->flag = CURSOR_NONE;
o->hstmt = SQL_NULL_HSTMT;
rv_numRets = 0;
memset(rv_type, 0, sizeof (rv_type));
/* free should never fail */
errorTrap(0);
exclist = 0;
} /* sql_free */
/**************************************************************************************************
AXFR
DNS-based zone transfer. Send all resource records for in QNAME's zone to the client.
**************************************************************************************************/
void
axfr(TASK *t) {
#if DEBUG_ENABLED && DEBUG_AXFR
struct timeval start = { 0, 0}, finish = { 0, 0 }; /* Time AXFR began and ended */
#endif
MYDNS_SOA *soa = NULL; /* SOA record for zone (may be bogus!) */
/* Do generic startup stuff; this is a child process */
signal(SIGALRM, axfr_timeout);
alarm(AXFR_TIME_LIMIT);
sql_close(sql);
db_connect();
#if DEBUG_ENABLED && DEBUG_AXFR
gettimeofday(&start, NULL);
DebugX("axfr", 1,_("%s: Starting AXFR for task ID %u"), desctask(t), t->internal_id);
#endif
total_records = total_octets = 0;
t->no_markers = 1;
/* Get SOA for zone */
soa = axfr_get_soa(t);
if (soa){
/* Transfer that zone */
axfr_zone(t, soa);
}
#if DEBUG_ENABLED && DEBUG_AXFR
/* Report result */
gettimeofday(&finish, NULL);
DebugX("axfr", 1,_("AXFR: %u records, %u octets, %.3fs"),
(unsigned int)total_records, (unsigned int)total_octets,
((finish.tv_sec + finish.tv_usec / 1000000.0) - (start.tv_sec + start.tv_usec / 1000000.0)));
#endif
t->qdcount = 1;
t->an.size = total_records;
task_output_info(t, NULL);
sockclose(t->fd);
_exit(EXIT_SUCCESS);
}
int
main (int argc, char *argv[])
{
int i = 0, j = 0;
st_sql_t *sql = NULL;
const char **row = NULL;
if (!(sql = sql_open ("localhost", 3306, "root", "nb", "mysql", SQL_MYSQL)))
return -1;
sql_write (sql, "SELECT * FROM user");
for (i = 0; (row = (const char **) sql_getrow (sql, i)); i++)
{
for (j = 0; row[j]; j++)
printf ("\"%s\" ", row[j]);
printf ("\n");
}
sql_write (sql, "SELECT * FROM user");
row = (const char **) sql_getrow (sql, 2);
if (row)
{
for (j = 0; row[j]; j++)
printf ("\"%s\" ", row[j]);
printf ("\n");
}
sql_write (sql, "SELECT * FROM user WHERE user = '******'");
for (i = 0; (row = (const char **) sql_getrow (sql, i)); i++)
{
for (j = 0; row[j]; j++)
printf ("\"%s\" ", row[j]);
printf ("\n");
}
sql_close (sql);
return 0;
}
int
main(int argc, char *argv[])
{
char *sql_db = NULL;
sqlite3* db;
char *username = NULL;
struct user user;
enum manage_action action = MANAGE_ACTION_HELP;
int opt;
char privid[OTP_PRIVID_HEX_LEN];
unsigned char *privid_bin;
int temp, ret;
struct otp_data* data;
char digest_name[DIGEST_NAME_MAX_SIZE];
char *ctemp;
while((opt = getopt(argc, argv, "hs:lg:r:a:c")) != -1) {
switch(opt) {
case 'h':
usage(0);
break;
case 's':
sql_db = optarg;
break;
case 'l':
if (action != MANAGE_ACTION_HELP) {
usage(1);
}
action = MANAGE_ACTION_LIST;
break;
case 'g':
if (action != MANAGE_ACTION_HELP) {
usage(1);
}
action = MANAGE_ACTION_GET;
username = optarg;
break;
case 'r':
if (action != MANAGE_ACTION_HELP) {
usage(1);
}
action = MANAGE_ACTION_DELETE;
username = optarg;
break;
case 'a':
if (action != MANAGE_ACTION_HELP) {
usage(1);
}
action = MANAGE_ACTION_ADD;
username = optarg;
break;
case 'c':
if (action != MANAGE_ACTION_HELP) {
usage(1);
}
action = MANAGE_ACTION_CREATE;
break;
default:
usage(0);
}
}
if(argc > optind) {
usage(1);
}
if (action == MANAGE_ACTION_HELP) {
usage(0);
}
if (sql_db == NULL) {
usage(2);
}
if (forget_real_credentials() != 0) {
printf("Unable to fix uid/gid\n");
return -EPERM;
}
db = init(sql_db);
if (db == NULL) {
printf("Unable to open the database\n");
return 1;
}
switch(action) {
case MANAGE_ACTION_HELP:
/* Already done */
break;
case MANAGE_ACTION_LIST:
list_users(db);
sql_close(db);
return 0;
case MANAGE_ACTION_CREATE:
create_database(db);
return 0;
case MANAGE_ACTION_GET:
case MANAGE_ACTION_ADD:
case MANAGE_ACTION_DELETE:
/* Later */
break;
}
if (username == NULL) {
usage(3);
}
if (verify_user(username, strlen(username), &user) != 0) {
printf("Unauthorized char in the username");
return OTP_ERR;
}
switch(action) {
case MANAGE_ACTION_HELP:
case MANAGE_ACTION_LIST:
case MANAGE_ACTION_CREATE:
/* Already done */
break;
case MANAGE_ACTION_GET:
data = get_otp_data(db, &user);
if (data == NULL) {
printf("No such user\n");
break;
}
printf("User '%.*s':\n", (unsigned int) user.len, user.name);
printf("Public ID : %.*s\n", (int) OTP_PUB_ID_HEX_LEN, data->pubid);
printf("Private Key: %.*s\n", (int) OTP_KEY_HEX_LEN, data->key);
printf("Private ID digest: %s\n", data->digest_name);
printf("Private ID hash: %s\n", data->privid_hash);
free(data);
break;
case MANAGE_ACTION_DELETE:
for (temp = 0; temp < MAX_RETRIES; ++temp) {
ret = try_start_transaction(db);
switch (ret) {
case OTP_SQL_ERR:
printf("SQL error during the transaction initialisation");
goto free_db;
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_OK:
ret = try_delete_credentials(db, &user);
switch (ret) {
case OTP_SQL_ERR:
printf("SQL error while trying to remove user");
goto free_db;
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_OK:
ret = try_end_transaction(db);
switch (ret) {
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_ERR:
printf("SQL error when trying to commit the transaction");
goto free_db;
case OTP_SQL_OK:
sql_close(db);
return 0;
}
}
}
}
printf("Unable to remove user (Database busy)\n");
break;
case MANAGE_ACTION_ADD:
data = calloc(sizeof(struct otp_data), 1ul);
if (data == NULL) {
printf("Malloc error\n");
goto free_db;
}
if (read_input_word(data->pubid, OTP_PUB_ID_HEX_LEN, "Public ID")) {
goto free_data;
}
if (check_modhex(data->pubid, OTP_PUB_ID_HEX_LEN) != 0) {
printf("Non hex character in input, please retry\n");
goto free_data;
}
if (read_input_word(data->key, OTP_KEY_HEX_LEN, "AES key")) {
goto free_data;
}
if (check_hex(data->key, (int) OTP_KEY_HEX_LEN) != 0) {
printf("Non hex character in input, please retry\n");
goto free_data;
}
if (read_input_word(privid, OTP_PRIVID_HEX_LEN, "Private ID")) {
goto free_data;
}
if (check_hex(privid, (int) OTP_PRIVID_HEX_LEN) != 0) {
printf("Non hex character in input, please retry\n");
goto free_data;
}
privid_bin = hex2bin(privid, OTP_PRIVID_HEX_LEN);
if (privid_bin == NULL) {
printf("Malloc error (bis)\n");
goto free_data;
}
printf("Please Specify a valid digest algorithm [%s]\n", DEFAULT_DIGEST);
memset(digest_name, 0, (size_t) DIGEST_NAME_MAX_SIZE);
ctemp = fgets(digest_name, DIGEST_NAME_MAX_SIZE, stdin);
if (ctemp == NULL) {
printf("Unable to read input\n");
goto free_data;
}
if (digest_name[DIGEST_NAME_MAX_SIZE - 1] != 0 && digest_name[DIGEST_NAME_MAX_SIZE - 1] != '\n') {
printf("Digest algorithm name too long, please retry\n");
goto free_data;
}
if (digest_name[0] == '\n') {
data->digest_name = strdup(DEFAULT_DIGEST);
} else {
ctemp = memchr(digest_name, '\n', (size_t) DIGEST_NAME_MAX_SIZE);
if (ctemp != NULL) {
*ctemp = '\0';
}
data->digest_name = digest_name;
}
ctemp = (char*)compute_hash(data->digest_name, (char*)privid_bin, OTP_PRIVID_BIN_LEN);
if (ctemp == NULL) {
goto free_data;
}
data->privid_hash = bin2hex(ctemp, strlen(ctemp));
if (data->privid_hash == NULL) {
goto free_data;
}
printf("New user :\n");
printf("Name: '%.*s':\n", (unsigned int) user.len, user.name);
printf("Public ID : %.*s\n", (int) OTP_PUB_ID_HEX_LEN, data->pubid);
printf("Private Key: %.*s\n", (int) OTP_KEY_HEX_LEN, data->key);
printf("Private ID: %.*s\n", (int) OTP_PRIVID_HEX_LEN, privid);
printf("Private ID digest: %s\n", data->digest_name);
printf("Private ID hash: %s\n", data->privid_hash);
printf("Press enter to create this new user\n");
if (getc(stdin) != '\n') {
goto free_data;
}
for (temp = 0; temp < MAX_RETRIES; ++temp) {
ret = try_start_transaction(db);
switch (ret) {
case OTP_SQL_ERR:
printf("SQL error during the transaction initialisation");
goto free_data;
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_OK:
ret = try_create_credentials(db, data, &user);
switch (ret) {
case OTP_SQL_ERR:
printf("SQL error while trying to add the user");
goto free_data;
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_OK:
ret = try_end_transaction(db);
switch (ret) {
case OTP_SQL_MAY_RETRY:
break;
case OTP_SQL_ERR:
printf("SQL error when trying to commit the transaction");
goto free_data;
case OTP_SQL_OK:
goto free_data;
}
}
}
}
printf("Unable to create user (Database busy)\n");
break;
}
goto free_db;
free_data:
free_otp_data(data);
free_db:
sql_close(db);
return 0;
}
