bool verificar_tablas(MYSQL *my_con)
{
std::vector<std::string> tablas, creates;
if(!leer_tablas("c:/prog/test/mydb.dat", tablas, creates))
{
std::cout << "Error leyendo las tablas." << std::endl;
return -1;
}
for(size_t i = 0; i < tablas.size(); ++i) {
if(!existe_tabla(my_con, tablas[i])) {
// Creamos la tabla.
std::cout << "Creamos la tabla: " << tablas[i] << std::endl;
if(mysql_query(my_con, creates[i].c_str())) {
std::string err_string("Error al crear la tabla " + tablas[i]);
print_mysql_error(my_con, err_string);
}
}
else {
std::cout << "La tabla " << tablas[i] << " ya existe." << std::endl;
}
}
std::cout << "Salimos de verificar_tablas()." << std::endl;
return true;
}
/**
* 获取当天操作纪录信息
*/
int
get_cur_history() {
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
time_t cur_time = time(NULL); //获取系统当前时间并格式化
struct tm *timeinfo;
timeinfo = localtime(&cur_time);
char date[MAX_BUF_SIZE];
memset(date, 0, sizeof(date));
strftime (date, sizeof(date), "history_%Y%m%d", timeinfo);
sprintf(sql, "SELECT * FROM `%s`", date);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
g_res = mysql_store_result(g_conn); //从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
print_result(); //打印
free_result(); //释放结果集
return EXIT_SUCCESS;
}
/*
* 切换当前目录
*/
char*
get_directory_id(char* diskName,char* dirName,char* parentId){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql,"SELECT directory_id FROM `directory_info` WHERE disk_name = '%s' AND directory_name = '%s' AND parent_id = '%s'", diskName,dirName,parentId);
if(mysql_query(g_conn,sql))
{
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn);
char dirId[MAX_BUF_SIZE];
memset(dirId, 0, sizeof(dirId));
if((g_row = mysql_fetch_row(g_res)))//符合条件的目录存在
{
sprintf(dirId, "%s",g_row[0]);
return dirId;
}
sprintf(dirId,"%s","false");
return dirId;
}
/**
* 获取所有的操作纪录信息
*/
int
get_all_history() {
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
GetProfileString("./etc/ast3_db_info.conf", "DB_INFO", "DBName", db_name);
sprintf(sql, "SELECT table_name FROM information_schema.tables WHERE table_schema='%s' AND table_type='base table' AND table_name LIKE 'history_%s'", db_name, "%");
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
g_res = mysql_store_result(g_conn); //从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
char *tbName = (char *) malloc(MAX_BUF_SIZE);
while ((g_row = mysql_fetch_row(g_res))) {
sprintf(tbName, "%s", g_row[0]); //获取记录数
// char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `%s`", tbName);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
MYSQL_RES *history; // mysql 记录集
history = mysql_store_result(g_conn); //从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
int i;
while ((g_row = mysql_fetch_row(history))) {
for(i=0; i<mysql_num_fields(history); i++){
printf("%s\t", g_row[i]);
}
printf("\n");
}
mysql_free_result(history);
}
return EXIT_SUCCESS;
}
bool actualizar_clientes(MYSQL *my_con, std::vector<Cliente> &lista_clientes)
{
MYSQL_STMT *stmt; // Manejador de la consulta preparada.
MYSQL_BIND my_bind[14]; // Estructura para los datos de la consulta.
data_bind_storage cmb(db_consts::cliente_nc_txt, // Reservamos espacio para
db_consts::cliente_nc_int, // almacenar los datos
db_consts::cliente_max_txt); // de un cliente.
// Ponemos la estructura para los datos a 0.
std::memset(static_cast<void *>(my_bind), 0, sizeof(my_bind));
// Reservamos manejador
if((stmt = mysql_stmt_init(my_con)) == NULL)
{
print_mysql_error(my_con, "Imposible inicializar el manejador de la consulta.");
return false;
}
// Preparamos la consulta.
if(mysql_stmt_prepare(stmt, db_queries::upd_cliente.c_str(), db_queries::upd_cliente.size()) != 0) {
print_mysql_stmt_error(stmt, "Imposible preparar consulta UPDATE.");
return false;
}
// Asociamos la estructura my_bind al almacen de datos.
set_mysql_bind(my_bind, cmb, db_binds::cliente_upd_bind);
// Asociamos los datos a la consulta.
if(mysql_stmt_bind_param(stmt, my_bind) != 0) {
print_mysql_stmt_error(stmt, "Imposible asociar los datos a la consulta.");
return false;
}
int i = 1;
for(auto &&c : lista_clientes) {
std::cout << "\rActualizando " << lista_clientes.size() << " clientes... ";
std::cout << utiles::to_string(i, 6, ' ') << "/" << utiles::to_string(lista_clientes.size(), 6, ' ');
// Rellenamos el "receptaculo" con los datos del cliente. La estructura
// my_bind está asociada a esta otra estructura, luego la consulta enviará
// los datos de esta estructura a traves de la estructura my_bind.
c.fill_mysql_bind(cmb);
// Procesamos la consulta con los datos.
if(mysql_stmt_execute(stmt) != 0) {
print_mysql_stmt_error(stmt, "Imposible ejecutar consulta preparada.");
return false;
}
++i;
}
std::cout << "\tHecho.\n\n";
mysql_stmt_close(stmt);
return true;
}
//插入NAT记录
void DbServer::addNat(char* nat_id,char *dport_str){
char sql[300];
int id = atoi(nat_id);
int dport = atoi(dport_str);
sprintf(sql,"update other_nat set dport='%d',state=1 where id='%d'",dport,id);
if(executesql(sql))
print_mysql_error(NULL);
else
printf("insert other_nat success! \n");
}
/**
* 记录操作日志
*/
int
insert_history(char* operation) {
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
time_t cur_time = time(NULL); //获取系统当前时间并格式化
struct tm *timeinfo;
timeinfo = localtime(&cur_time);
char date[MAX_BUF_SIZE];
memset(date, 0, sizeof(date));
strftime(date, sizeof(date), "history_%Y%m%d", timeinfo);
char time[MAX_BUF_SIZE];
memset(time, 0, sizeof(time));
strftime(time, sizeof(time), "%F %T", timeinfo);
sprintf(sql, "CREATE TABLE IF NOT EXISTS `%s` ( `id` int(11) NOT NULL AUTO_INCREMENT, `operation` varchar(255) NOT NULL,`time` datetime NOT NULL, PRIMARY KEY (`id`))", date);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
//插入数据
memset(sql, 0, sizeof(sql));
sprintf(sql, "INSERT INTO `%s`(operation, time)VALUES ('%s', '%s')", date, operation, time);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/**
* 插入目录信息
*/
int
insert_directory(db_directory_info *directory_info){
if (db_directory_info__insert (directory_info) != 0){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
printf("insert data into directory_info successfully\n");
return EXIT_SUCCESS;
}
/**
* 插入文件信息
*/
int
insert_file(db_file_info *file_info){
if (db_file_info__insert (file_info) != 0){
print_mysql_error(NULL);
return EXIT_FAILURE;
}
printf("insert data into file_info successfully\n");
return EXIT_SUCCESS;
}
int update_datos_cliente(MYSQL *my_con, const Cliente &c)
{
std::string consulta = c.get_mysql_update_str();
if(mysql_query(my_con, consulta.c_str()) != 0) {
print_mysql_error(my_con, "Fallo al actualizar cliente.");
return 1;
}
return 0;
}
/**
* 根据位置查询文件信息
*/
int
query_file_by_curr_location(char* diskName,char* dirId,char *start_ra, char *end_ra, char *start_dec, char *end_dec){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `file_info` Where ra_val >= '%s' AND ra_val <= '%s' AND dec_val >= '%s' AND dec_val <= '%s' AND disk_name = '%s' AND directory_id = '%s'",
start_ra, end_ra, start_dec, end_dec,diskName,dirId);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
print_result();
free_result();
memset(sql,0,sizeof(sql));
sprintf(sql,"SELECT directory_id FROM 'directory_info' WHERE disk_name = '%s' AND parent_id = '%s'",diskName,dirId);
if(mysql_query(g_conn,sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn);
int i;
char* childId = (char*)malloc(MAX_BUF_SIZE);
while((g_row = mysql_fetch_row(g_res)))
{
for(i = 0; i < get_fields(g_res); i++)
{
memset(childId,0,sizeof(childId));
sprintf(childId,"%s",g_row[i]);
query_file_by_curr_location(diskName,childId,start_ra,end_ra,start_dec,end_dec);
}
}
return EXIT_SUCCESS;
}
/**
* 查询目录内文件和目录详细信息
*/
int
query_directory_primary_info(char *diskName, char *dirId){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT file_id,file_name,file_size,time,permission FROM `file_info` Where disk_name = '%s' AND directory_id = '%s'", diskName, dirId);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 根据时间查询文件信息
*/
int
query_file_by_time(char *start_time, char * end_time){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `file_info` Where time >= '%s' AND time <= '%s'", start_time, end_time);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 查询所有硬盘详细信息
*/
int
query_all_disks(){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `disk_info`");
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 查询所有硬盘基本信息--id,name,容量，权限，状态
*/
int
query_primary_disks(){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT disk_id,disk_name,permission,disk_capacity,disk_status FROM `disk_info`");
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 查询文件信息
*/
int
query_file_info(char *fileName, char *dirName, char *diskName){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `file_info` Where file_name = '%s' AND directory_name = '%s' AND disk_name = '%s'", fileName, dirName, diskName);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 根据位置查询文件信息
*/
int
query_file_by_location(char *start_ra, char *end_ra, char *start_dec, char *end_dec){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT * FROM `file_info` Where ra_val >= '%s' AND ra_val <= '%s' AND dec_val >= '%s' AND dec_val <= '%s'",
start_ra, end_ra, start_dec, end_dec);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
return EXIT_SUCCESS;
}
/**
* 返回指定ID的目录
*/
char*
return_directory(char *dirID, char *diskName){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT directory_name FROM `directory_info` Where directory_id = '%s' AND disk_name = '%s'", dirID, diskName);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
char *directory = (char *) malloc(MAX_BUF_SIZE);
int i;
g_row = mysql_fetch_row(g_res);
sprintf(directory,"%s", g_row[i]);
return directory;
}
/**
* 更新文件信息
* 包括 `recent_use_time`, `accessed_time`
*/
void
update_file(db_file_info *file_info){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
//格式化时间
struct tm * tm_local = localtime(&file_info->recent_use_time);
char str_f_t [MAX_BUF_SIZE];
strftime(str_f_t, sizeof(str_f_t), "%G-%m-%d %H:%M:%S", tm_local);
sprintf(sql, "UPDATE `file_info` SET recent_use_time = '%s', accessed_time = %d WHERE file_id = %d",
str_f_t, file_info->accessed_time, file_info->file_id);
int res = mysql_query(g_conn, sql);
if (!res) {
printf("Update %lu rows\n", (unsigned long)mysql_affected_rows(g_conn));
} else {
print_mysql_error(NULL);
}
}
/**
* 获取父目录ID
* 已知当前目录ID
*/
char*
get_parent_id(char *dirId){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT parent_id FROM 'directory_info' WHERE directory_id = '%s'",dirId);
if(mysql_query(g_conn,sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn);// 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
char *parentId = (char*)malloc(MAX_BUF_SIZE);
if((g_row = mysql_fetch_row(g_res)))
{
sprintf(parentId,"%s",g_row[0]);
}
return parentId;
}
/**
* 更新磁盘信息
* 包括 `disk_used`, `recent_use_time`, `disk_status`
*/
void
update_disk(db_disk_info *disk_info) {
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
//格式化时间
struct tm * tm_local = localtime(&disk_info->recent_use_time);
char str_f_t [MAX_BUF_SIZE];
strftime(str_f_t, sizeof(str_f_t), "%G-%m-%d %H:%M:%S", tm_local);
sprintf(sql, "UPDATE `disk_info` SET disk_used = %d, recent_use_time = '%s', disk_status = %d WHERE disk_id = %d",
disk_info->disk_used, str_f_t, disk_info->disk_status, disk_info->disk_id);
int res = mysql_query(g_conn, sql);
if (!res) {
printf("Update %lu rows\n", (unsigned long)mysql_affected_rows(g_conn));
} else {
print_mysql_error(NULL);
}
}
bool existe_cliente(MYSQL *my_con, int codigo_cliente)
{
std::string consulta = "SELECT * FROM CLIENTE WHERE cod_cliente=" + utiles::IntToStr(codigo_cliente, 6);
MYSQL_RES *my_res;
bool valor_ret = false;
if(mysql_query(my_con, consulta.c_str()) != 0) {
std::string err_string("Fallo al consultar existencia del cliente " + utiles::IntToStr(codigo_cliente, 6));
print_mysql_error(my_con, err_string);
valor_ret = false;
}
else {
if((my_res = mysql_store_result(my_con)) != NULL) {
// Procesar resultados
if(mysql_num_rows(my_res) != 0) valor_ret = true;
// Liberar el resultado de la consulta:
mysql_free_result(my_res);
}
}
return valor_ret;
}
bool existe_tabla(MYSQL *my_con, std::string &tabla)
{
std::string consulta = "SHOW TABLES FROM sepyadb LIKE \'" + tabla + "\'";
MYSQL_RES *my_res;
bool valor_ret = true;
if(mysql_query(my_con, consulta.c_str()) != 0) {
std::string err_string("Fallo al consultar existencia de la tabla " + tabla);
print_mysql_error(my_con, err_string);
valor_ret = false;
}
else {
if((my_res = mysql_store_result(my_con)) != NULL) {
// Procesar resultados
if(!mysql_num_rows(my_res)) valor_ret = false;
// Liberar el resultado de la consulta:
mysql_free_result(my_res);
}
}
return valor_ret;
}
/**
* 获取文件ID
*/
char*
get_file_id(char *fileName, char *dirName, char *diskName){
char sql[MAX_BUF_SIZE];
memset(sql, 0, sizeof(sql));
sprintf(sql, "SELECT file_id FROM `file_info` Where file_name = '%s' AND directory_name = '%s' AND disk_name = '%s'", fileName, dirName, diskName);
if (mysql_query(g_conn, sql)){
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn); // 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
char *file_id = (char *) malloc(MAX_BUF_SIZE);
int i;
while ((g_row = mysql_fetch_row(g_res))) {
for(i=0; i<get_fields(); i++){
sprintf(file_id, "%s", g_row[i]); //获取目录ID
}
}
return file_id;
}
/**
* 获取目录名
* 已知目录ID
*/
char*
get_directory_name(char *dirId){
char* sql[MAX_BUF_SIZE];
memset(sql,0,sizeof(sql));
sprintf(sql,"SELECT directory_name FROM `directoty_info` WHERE directory_id = '%s'",dirId);
if(mysql_query(g_conn,sql))
{
print_mysql_error(NULL);
}
g_res = mysql_store_result(g_conn);// 从服务器传送结果集至本地，mysql_use_result直接使用服务器上的记录集
char* dirName = (char*)malloc(MAX_BUF_SIZE);
if((g_row = mysql_fetch_row(g_res)))
{
sprintf(dirName,"%s",g_row[0]);
}
return dirName;
}
int main(int argc, const char *argv[])
{
/* Initialize all query strings */
const char *create_schema = "CREATE SCHEMA IF NOT EXISTS %s;";
const char *create_table = "CREATE TABLE IF NOT EXISTS %s.zend_cf_remove_servers(id INTEGER);";
const char *select_remove_servers = "SELECT id FROM %s.zend_cf_remove_servers;";
const char *delete_server = "DELETE FROM %s.zend_cf_remove_servers WHERE id = %d;";
/* Check that number of parameters is correct */
if(argc == 1) { /* No params = do nothing */
while(true) {
int status;
sleep(10 * MY_SLEEP_SECONDS);
waitpid(-1,&status,WNOHANG);
}
}
if(argc != 9) {
usage(argv[0]);
exit(1);
}
/* Allocate memory for query buffer */
if((query = malloc(sizeof(char) * 1024)) == NULL) {
exit(3);
}
/* Parse prgram arguments */
params.mysql_hostname = argv[1];
params.mysql_port = atoi(argv[2]);
params.mysql_username = argv[3];
params.mysql_password = argv[4];
params.mysql_dbname = argv[5];
params.server_id = atoi(argv[6]);
params.web_api_key_name = argv[7];
params.web_api_key = argv[8];
/* Setup signal handler */
signal(SIGTERM, term_handler);
/* Initialize MySQL connection */
mysql_init(&mysql);
my_bool recon = true;
mysql_options(&mysql,MYSQL_OPT_RECONNECT,&recon); /* Set option to auto
* restart mysql connection */
if(mysql_real_connect(&mysql,params.mysql_hostname,params.mysql_username,params.mysql_password,NULL,params.mysql_port,NULL,CLIENT_REMEMBER_OPTIONS) == NULL) {
finish_with_error();
}
/* Create schema if needed */
sprintf(query,create_schema,params.mysql_dbname);
if(mysql_query(&mysql,query))
print_mysql_error();
/* Create table that will hold IDs of ZS nodes to remove */
sprintf(query,create_table,params.mysql_dbname);
if(mysql_query(&mysql,query))
print_mysql_error();
MYSQL_RES *result;
MYSQL_ROW row;
int status;
int server_id;
while(true) { /* Loop forever */
/* Query server IDs that should be removed */
sprintf(query,select_remove_servers,params.mysql_dbname);
if(mysql_query(&mysql,query)) {
print_mysql_error();
} else {
result = mysql_store_result(&mysql);
while((row = mysql_fetch_row(result))) {
/* Delete server from Zend Server cluster by calling zs-manage */
server_id = atoi(row[0]);
sprintf(query,"/usr/local/zend/bin/zs-manage cluster-remove-server %d -N %s -K %s -f",server_id,params.web_api_key_name,params.web_api_key);
fprintf(stderr,"%s\n",query);
/* If call to zs-manage failed, print FAILED on stderr */
if(system(query) == -1) {
fprintf(stderr,"FAILED\n");
}
/* Delete server ID from table */
sprintf(query,delete_server,params.mysql_dbname,server_id);
if(mysql_query(&mysql,query)) {
print_mysql_error();
}
}
}
/* waitpid call to prevent zombie processes */
waitpid(-1,&status,WNOHANG);
sleep(MY_SLEEP_SECONDS);
}
}
int get_datos_cliente(MYSQL *my_con, int codigo, Cliente &c)
{
std::string consulta = "SELECT * FROM cliente WHERE COD_CLIENTE=" + utiles::to_string(codigo, 6);
MYSQL_RES *resultado;
MYSQL_ROW fila;
if(mysql_query(my_con, consulta.c_str()) != 0) {
print_mysql_error(my_con, "Fallo al seleccionar un cliente.");
return 1;
}
else {
if((resultado = mysql_store_result(my_con)) == NULL) {
print_mysql_error(my_con, "Fallo al almacenar el resultado.");
return 2;
}
else {
if(static_cast<int>(mysql_num_rows(resultado)) > 1) {
print_mysql_error(my_con, "Varios clientes con el mismo codigo.");
return 3;
}
if(static_cast<int>(mysql_num_fields(resultado)) != 15) {
print_mysql_error(my_con, "El numero de columnas no coincide.");
return 4;
}
// Columna Contenido Tipo
// ------- --------- ----
// 0 id_cliente Entero (No usable, interno BD)
// 1 cod_cliente Entero
// 2 razon_social Texto
// 3 domicilio Texto
// 4 cod_postal Texto
// 5 poblacion Texto
// 6 provincia Texto
// 7 nif Texto
// 8 tel1 Texto
// 9 tel2 Texto
// 10 fax Texto
// 11 forma_pago Entero
// 12 categoria Entero
// 13 swift_bic Texto
// 14 iban Texto
while((fila = mysql_fetch_row(resultado)) != NULL) {
c.codigo = (fila[1] != NULL) ? utiles::to_integer(fila[1]) : 0;
c.razon_social = fila[2];
c.domicilio = fila[3];
c.codigo_postal = fila[4];
c.poblacion = fila[5];
c.provincia = fila[6];
c.nif = fila[7];
c.tel1 = fila[8];
c.tel2 = fila[9];
c.fax = fila[10];
c.forma_pago = (fila[11] != NULL) ? utiles::to_integer(fila[11]) : 0;
c.categoria = (fila[12] != NULL) ? utiles::to_integer(fila[12]) : 0;
c.swift_bic = fila[13];
c.iban = fila[14];
}
mysql_free_result(resultado);
}
}
return 0;
}
