void LoginSettingWidget::initWidgets()
{
dest_addr_label = new QLabel();
dest_port_label = new QLabel();
dest_addr_edit = new QLineEdit();
dest_port_edit = new QLineEdit();
dest_addr_edit->setAlignment(Qt::AlignLeft);
dest_port_edit->setAlignment(Qt::AlignLeft);
dest_addr_edit->setFixedWidth(120);
dest_port_edit->setFixedWidth(120);
dest_addr_edit->setPlaceholderText(tr("Enter Target Device IP Address"));
dest_port_edit->setPlaceholderText(tr("Enter Target Port Number"));
QString ip_regexp("([1-9]|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])(\\.(\\d|[1-9]\\d|1\\d{2}|2[0-4]\\d|25[0-5])){3}");
QValidator *ip_validator = new QRegExpValidator(QRegExp(ip_regexp));
dest_addr_edit->setValidator(ip_validator);
QString port_regexp("^[1-9]$|(^[1-9][0-9]$)|(^[1-9][0-9][0-9]$)|(^[1-9][0-9][0-9][0-9]$)|(^[1-6][0-5][0-5][0-3][0-5]$)");
QValidator *port_validator = new QRegExpValidator(QRegExp(port_regexp));
dest_port_edit->setValidator(port_validator);
ok_button = new QPushButton();
cancel_button = new QPushButton();
//cancel_button->setDefault(true);
connect(ok_button, SIGNAL(clicked()), this, SLOT(onOkButtonClicked()));
connect(cancel_button, SIGNAL(clicked()), this, SIGNAL(showLogin()));
}
void ConfConexoesWidget::carregarConfiguracao(void)
{
vector<QString> atribs_chave;
map<QString, map<QString, QString> >::iterator itr, itr_end;
ConexaoBD *conexao=NULL;
//Expressão regular usada para validar o endereço digitado para o servidor
QRegExp ip_regexp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
//Para a sessão de configuração de conexões, o 'alias' será usado como campo chave
atribs_chave.push_back(AtributosParsers::ALIAS);
//Carrega as configurações
ConfBaseWidget::carregarConfiguracao(AtributosGlobais::CONF_CONEXOES, atribs_chave);
itr=params_config.begin();
itr_end=params_config.end();
while(itr!=itr_end)
{
//Aloca uma nova conexão
conexao=new ConexaoBD;
/* Caso o host da conexão seja um IP, atribui o valor ao parâmetro,
ConexaoBD::PARAM_IP_SERVIDOR da conexão. Caso contrário atribui ao
ConexaoBD::PARAM_FQDN_SERVIDOR. A libpq trata separadamente IP e FQDN do servidor
por isso é necessária esta distinção */
if(ip_regexp.exactMatch(itr->second[ConexaoBD::PARAM_FQDN_SERVIDOR]))
conexao->definirParamConexao(ConexaoBD::PARAM_IP_SERVIDOR, itr->second[ConexaoBD::PARAM_FQDN_SERVIDOR]);
else
conexao->definirParamConexao(ConexaoBD::PARAM_FQDN_SERVIDOR, itr->second[ConexaoBD::PARAM_FQDN_SERVIDOR]);
//Atribuindo os demais valores à conexão
conexao->definirParamConexao(ConexaoBD::PARAM_PORTA, itr->second[ConexaoBD::PARAM_PORTA]);
conexao->definirParamConexao(ConexaoBD::PARAM_USUARIO, itr->second[ConexaoBD::PARAM_USUARIO]);
conexao->definirParamConexao(ConexaoBD::PARAM_SENHA,itr->second[ConexaoBD::PARAM_SENHA]);
conexao->definirParamConexao(ConexaoBD::PARAM_NOME_BD, itr->second[ConexaoBD::PARAM_NOME_BD]);
conexao->definirParamConexao(ConexaoBD::PARAM_TEMPO_CONEXAO, itr->second[ConexaoBD::PARAM_TEMPO_CONEXAO]);
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, itr->second[ConexaoBD::PARAM_MODO_SSL]);
conexao->definirParamConexao(ConexaoBD::PARAM_CERT_RAIZ_SSL, itr->second[ConexaoBD::PARAM_CERT_RAIZ_SSL]);
conexao->definirParamConexao(ConexaoBD::PARAM_CERT_SSL, itr->second[ConexaoBD::PARAM_CERT_SSL]);
conexao->definirParamConexao(ConexaoBD::PARAM_CHAVE_SSL, itr->second[ConexaoBD::PARAM_CHAVE_SSL]);
conexao->definirParamConexao(ConexaoBD::PARAM_CRL_SSL, itr->second[ConexaoBD::PARAM_CRL_SSL]);
conexao->definirParamConexao(ConexaoBD::PARAM_LIB_GSSAPI, itr->second[ConexaoBD::PARAM_LIB_GSSAPI]);
conexao->definirParamConexao(ConexaoBD::PARAM_SERVIDOR_KERBEROS, itr->second[ConexaoBD::PARAM_SERVIDOR_KERBEROS]);
conexao->definirParamConexao(ConexaoBD::PARAM_OPCOES, itr->second[ConexaoBD::PARAM_OPCOES]);
//Adiciona a conexão ao combo de conexões
conexoes_cmb->addItem(QString::fromUtf8(itr->second[AtributosParsers::ALIAS]),
QVariant::fromValue<void *>(reinterpret_cast<void *>(conexao)));
itr++;
}
/* Habilita os botões de edição e exclusão caso, após o carregamento,
hajam conexões inseridas no combo */
editar_tb->setEnabled(conexoes_cmb->count() > 0);
excluir_tb->setEnabled(conexoes_cmb->count() > 0);
}
void ConnectionsConfigWidget::configurarConexao(DBConnection *conn)
{
if(conn)
{
QRegExp ip_regexp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
if(ip_regexp.exactMatch(host_edt->text()))
conn->setConnectionParam(DBConnection::PARAM_SERVER_IP, host_edt->text());
else
conn->setConnectionParam(DBConnection::PARAM_SERVER_FQDN, host_edt->text());
conn->setConnectionParam(DBConnection::PARAM_PORT, QString("%1").arg(port_sbp->value()));
conn->setConnectionParam(DBConnection::PARAM_USER, user_edt->text());
conn->setConnectionParam(DBConnection::PARAM_PASSWORD, passwd_edt->text());
conn->setConnectionParam(DBConnection::PARAM_DB_NAME, conn_db_edt->text());
conn->setConnectionParam(DBConnection::PARAM_CONN_TIMEOUT, QString("%1").arg(timeout_sbp->value()));
switch(ssl_mode_cmb->currentIndex())
{
case 1:
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, DBConnection::SSL_ALLOW);
break;
case 2:
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, DBConnection::SSL_REQUIRE);
break;
case 3:
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, DBConnection::SSL_CA_VERIF);
break;
case 4:
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, DBConnection::SSL_FULL_VERIF);
break;
default:
case 0:
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, DBConnection::SSL_DESABLE);
break;
}
if(ssl_mode_cmb->currentIndex()!=0)
{
conn->setConnectionParam(DBConnection::PARAM_SSL_ROOT_CERT, root_cert_edt->text());
conn->setConnectionParam(DBConnection::PARAM_SSL_CERT, client_cert_edt->text());
conn->setConnectionParam(DBConnection::PARAM_SSL_KEY, client_key_edt->text());
conn->setConnectionParam(DBConnection::PARAM_SSL_CRL, crl_edt->text());
}
if(gssapi_auth_chk->isChecked())
conn->setConnectionParam(DBConnection::PARAM_LIB_GSSAPI, "gssapi");
if(!krb_server_edt->text().isEmpty())
conn->setConnectionParam(DBConnection::PARAM_KERBEROS_SERVER, krb_server_edt->text());
if(!options_edt->text().isEmpty())
conn->setConnectionParam(DBConnection::PARAM_OPTIONS, options_edt->text());
}
}
void ConnectionsConfigWidget::loadConfiguration(void)
{
vector<QString> key_attribs;
map<QString, map<QString, QString> >::iterator itr, itr_end;
DBConnection *conn=NULL;
//Regexp used to validate the host address
QRegExp ip_regexp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
key_attribs.push_back(ParsersAttributes::ALIAS);
BaseConfigWidget::loadConfiguration(GlobalAttributes::CONNECTIONS_CONF, key_attribs);
itr=config_params.begin();
itr_end=config_params.end();
while(itr!=itr_end)
{
conn=new DBConnection;
if(ip_regexp.exactMatch(itr->second[DBConnection::PARAM_SERVER_FQDN]))
conn->setConnectionParam(DBConnection::PARAM_SERVER_IP, itr->second[DBConnection::PARAM_SERVER_FQDN]);
else
conn->setConnectionParam(DBConnection::PARAM_SERVER_FQDN, itr->second[DBConnection::PARAM_SERVER_FQDN]);
conn->setConnectionParam(DBConnection::PARAM_PORT, itr->second[DBConnection::PARAM_PORT]);
conn->setConnectionParam(DBConnection::PARAM_USER, itr->second[DBConnection::PARAM_USER]);
conn->setConnectionParam(DBConnection::PARAM_PASSWORD,itr->second[DBConnection::PARAM_PASSWORD]);
conn->setConnectionParam(DBConnection::PARAM_DB_NAME, itr->second[DBConnection::PARAM_DB_NAME]);
conn->setConnectionParam(DBConnection::PARAM_CONN_TIMEOUT, itr->second[DBConnection::PARAM_CONN_TIMEOUT]);
conn->setConnectionParam(DBConnection::PARAM_SSL_MODE, itr->second[DBConnection::PARAM_SSL_MODE]);
conn->setConnectionParam(DBConnection::PARAM_SSL_ROOT_CERT, itr->second[DBConnection::PARAM_SSL_ROOT_CERT]);
conn->setConnectionParam(DBConnection::PARAM_SSL_CERT, itr->second[DBConnection::PARAM_SSL_CERT]);
conn->setConnectionParam(DBConnection::PARAM_SSL_KEY, itr->second[DBConnection::PARAM_SSL_KEY]);
conn->setConnectionParam(DBConnection::PARAM_SSL_CRL, itr->second[DBConnection::PARAM_SSL_CRL]);
conn->setConnectionParam(DBConnection::PARAM_LIB_GSSAPI, itr->second[DBConnection::PARAM_LIB_GSSAPI]);
conn->setConnectionParam(DBConnection::PARAM_KERBEROS_SERVER, itr->second[DBConnection::PARAM_KERBEROS_SERVER]);
conn->setConnectionParam(DBConnection::PARAM_OPTIONS, itr->second[DBConnection::PARAM_OPTIONS]);
connections_cmb->addItem(Utf8String::create(itr->second[ParsersAttributes::ALIAS]),
QVariant::fromValue<void *>(reinterpret_cast<void *>(conn)));
itr++;
}
edit_tb->setEnabled(connections_cmb->count() > 0);
remove_tb->setEnabled(connections_cmb->count() > 0);
}
void DBConnection::setConnectionParam(const QString ¶m, const QString &value)
{
//Regexp used to validate the host address
QRegExp ip_regexp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
//Raise an error in case the param name is empty
if(param=="")
throw Exception(ERR_ASG_INV_CONN_PARAM, __PRETTY_FUNCTION__, __FILE__, __LINE__);
/* Set the value to the specified param on the map.
One special case is treated here, if user use the parameter SERVER_FQDN and the value
is a IP address, the method will assign the value to the SERVER_IP parameter */
if(param==PARAM_SERVER_FQDN && ip_regexp.exactMatch(value))
connection_params[DBConnection::PARAM_SERVER_IP]=value;
else
connection_params[param]=value;
//Updates the connection string
generateConnectionString();
}
void ConfConexoesWidget::configurarConexao(ConexaoBD *conexao)
{
if(conexao)
{
QRegExp ip_regexp("[0-9]+\\.[0-9]+\\.[0-9]+\\.[0-9]+");
/* Caso o nome do host especificado no formulário seja um IP (combinando com a expressão regular)
atribui o valor ao campo respectivo na conexão. Caso contrário atribui ao campo de
nome de host (fqdn) */
if(ip_regexp.exactMatch(host_edt->text()))
conexao->definirParamConexao(ConexaoBD::PARAM_IP_SERVIDOR, host_edt->text());
else
conexao->definirParamConexao(ConexaoBD::PARAM_FQDN_SERVIDOR, host_edt->text());
//Atribuindo os valores básicos de conexão
conexao->definirParamConexao(ConexaoBD::PARAM_PORTA, QString("%1").arg(porta_sbp->value()));
conexao->definirParamConexao(ConexaoBD::PARAM_USUARIO, usuario_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_SENHA, senha_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_NOME_BD, bd_conexao_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_TEMPO_CONEXAO, QString("%1").arg(timeout_sbp->value()));
//Configurando o modo SSL da conexão
switch(modo_ssl_cmb->currentIndex())
{
case 1:
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, ConexaoBD::SSL_PERMITIR);
break;
case 2:
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, ConexaoBD::SSL_REQUERER);
break;
case 3:
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, ConexaoBD::SSL_VERIF_AUT_CERT);
break;
case 4:
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, ConexaoBD::SSL_VERIF_COMPLETA);
break;
default:
case 0:
conexao->definirParamConexao(ConexaoBD::PARAM_MODO_SSL, ConexaoBD::SSL_DESATIVADO);
break;
}
//Caso haja um modo SSL selecionado, atribui os certificados usados para conexão
if(modo_ssl_cmb->currentIndex()!=0)
{
conexao->definirParamConexao(ConexaoBD::PARAM_CERT_RAIZ_SSL, cert_raiz_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_CERT_SSL, cert_cliente_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_CHAVE_SSL, chave_cli_edt->text());
conexao->definirParamConexao(ConexaoBD::PARAM_CRL_SSL, crl_edt->text());
}
//Especificando autenticação GSSAPI caso esteja marcada no formulário
if(aut_gssapi_chk->isChecked())
conexao->definirParamConexao(ConexaoBD::PARAM_LIB_GSSAPI, "gssapi");
//Especificando o endereço do servidor Kerberus quando especificado
if(!serv_kerberus_edt->text().isEmpty())
conexao->definirParamConexao(ConexaoBD::PARAM_SERVIDOR_KERBEROS, serv_kerberus_edt->text());
//Atribuindo opções adicionas de conexão
if(!opcoes_edt->text().isEmpty())
conexao->definirParamConexao(ConexaoBD::PARAM_OPCOES, opcoes_edt->text());
}
}