Hola. Estoy aprendiendo algo sobre los Arboles B, una estructura de datos. No sé si este sea el sitio adecuado, pero tengo varias interrogantes acerca de ese Arbol:

No entiendo como cuál es la lógica que sigue el arból. Entiendo bien los términos de nodos hijos y nodos padres, pero no entiendo como funciona. ¿Puede alguien darme una explicacion un poco más sencilla que las que aparecen en internet? Por si acaso, seguiré buscando...

¿Los nodos de izquiera a derecha, van de menor valor a mayor?



Gracias por su ayuda.

Hola, estoy desarrollando una aplicacion sencilla que usa bases de datos SQLite en C/C++. Al hacer la consulta que crea una TABLA si no existe, la aplicacion hace una VIOLACION DE MEMORIA. He estado revisando con el depurador, pero no lo he podido conseguir.

No encontre un subforo adecuado para este tema, así que lo posteé aquí. Disculpen si aquí no iba. XD. El código es el siguiente:

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <sqlite3.h>
 
///Global variables
sqlite3 *db;
char *zErrMsg = 0;
int rc;
char sql[128];
 
   ///Used to extract interesting data from callbacks.
int number_of_rows_fetched;
int money;
int money2;
const char *data = "Callback function called!!\n";
 
///This function is called each time that a row if found.
///The only way to keep tracking how many rows has the table,
///it's increasing the counter.
static int callback(void *data, int argc, char **argv, char **azColName){
   printf("Callback is running!!\n");
 
   return 0;
}
 
 
int init(){
 
    ///Open database
   rc = sqlite3_open("bank.db", &db);
   if(rc != SQLITE_OK){
      fprintf(stderr, "Can't open database: %s\n", sqlite3_errmsg(db));
      exit(0);
   }else{
      fprintf(stderr, "Opened database successfully\n");
   }
 
 
 
   ///Create Table if it doesn't exist
   memset(sql, 0, sizeof(sql));
   strcat(sql, "CREATE TABLE accounts("  \
         "id INT            NOT NULL," \
         "username           TEXT    NOT NULL," \
         "password           TEXT    NOT NULL," \
         "cash               INT);");
 
   ///Run query
   rc = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
   printf("After the crash, i still alive\n");
   if( rc != SQLITE_OK ){
   fprintf(stderr, "SQL error: %s\n", zErrMsg);
      sqlite3_free(zErrMsg);
   }else{
      fprintf(stdout, "Table created successfully\n");
   }
 
}
 
int main(int argc, char* argv[])
{
 
   init();
 
   return 0;
}
 
 

Realmente he tenido dudas sobre si este tópico iría en este subforo, pero como no encuentro algo relacionado con Bases de Datos directamente, quise postearlo aqui.

Gracias de antemano.

Hola, amigos. Estoy desarrollando una aplicacion de login que permite la creacion de nuevos usuarios. Para hacerlo, primero debe saber si ya existe, antes de insertarlo.

He estado buscando en la web, y aparecen algunos métodos, pero siempre son aplicados a lenguajes diferentes a C/C++. Usan Java, y demás, y esas soluciones no son convertibles a C++.

Estoy usando la libreria de SQlite en C/C++. Pero no consigo obtener algo que me pueda ayudar a saber si ya existe un registro.

Intenté hacer un SELECT para que retorne los usarios existentes bajo ese nick, y luego medir la cantidad de resultados, si es mayor a 0, existe. Pero no he podido implementarlo en C/C++, no consigo como hacerlo.

Gracias de antemano. Seguiré buscando en otras fuentes también...

Hola, amigos. Estoy desarrollando un programa que rellena las casillas de un array con una X según la posicion y las ordenes que se indiquen desde un fichero de texto que actúa como script.

En cuanto al programa, mi único problema está en la parte en donde interpreta los scripts.

Voy dividiendo linea por linea usando strtok(...), y hasta ahí todo bien. Copio el contenido del puntero que devuelve strtok hacia un buffer de 16 caracteres para no tener que preocuparme por cosas raras con punteros.

El problema viene cuando intento usar strcmp(...) para ver si la linea actual coincide con la instruccion "fill" o "inc_x". Cuando lo hace, el programa crashea.

¿Podría alguien ayudarme a solucionar mi problema, o darme una mejor idea de como hacerlo? Gracias de antemano

#include <stdio.h>
#include <stdlib.h>
 
#define NROWS 5//32
#define NCOLUMNS 5//32
int parse_script(char filename[]){
    unsigned int x = 0;
    unsigned int y = 0;
    char array[NROWS][NCOLUMNS];
    unsigned int file_size;
    unsigned int i = 0;
 
    FILE *script_file;
    char *script_content;
    char *current_line;
    char current_instruction[16];
 
    for(x = 0; x < NCOLUMNS; x++){
        for(y = 0; y < NROWS; y++){
            array[x][y] = 'O';
        }
    }
 
    ///First step, read all file content before preprocess it.
    script_file = fopen(filename, "r");
 
    ///If all is good, get the size of file
    fseek(script_file, 0, SEEK_END);
    file_size = (unsigned long ) ftell(script_file);
    rewind(script_file);
 
    ///Resize the array to the size of file
    script_content = (char *) calloc (1, (size_t) file_size);
 
    ///Read the data from the file and put it in the array
    fread((char *)script_content, file_size, 1, script_file);    ///Last step: Free resources
 
    ///Second step: Execute instruction by instruction
    ///The program must divide the content in lines using \n
    x = 0;
    y = 0;
    char delimiters[] = "\r\n";
    current_line = strtok((char *) script_content, delimiters);//argumentos: frase, caracter delimitador
    while(current_line != NULL)
    {
 
       strncpy(current_instruction, current_line, 16);
       printf("%s \n", current_line);
 
       ///Here, the program must analyze the instruction and take an action
       if(strcmp("fill", current_instruction) == 0){
            array[x][y] = 'X';
 
       }
 
       if(strcmp("inc_x", current_instruction) == 0){
            x++;
 
       }
 
       current_line = strtok(NULL, delimiters);
    }
 
    ///Third step: Show array.
    printf("\nThe content of the array is: \n");
    for(x = 0; x < NCOLUMNS; x++){
        for(y = 0; y < NROWS; y++){
            printf("%c", array[x][y]);
            printf(" ");
        }
        printf("\n");
 
    }
    printf("End of array. Thanks for use my program\n");
 
    free(script_content);
    fclose(script_file);
}
 
int main(int argc, char *argv[])
{
    if(argc < 2)
        return -1;
 
 
 
    if(strcmp(argv[1], "-w") == 0){
        parse_script(argv[2]);
        return 0;
    }
 
    printf("Invalid command!!\n");
 
    return 0;
}
 
 

Fichero de prueba usado (escribir su ruta en la linea de comandos como parametro despues del nombre del ejecutable):

fill
inc_x
 

Hola, estoy desarrollando un motor metamorfico. Sé que es algo dificil, pero si uno no empieza no acaba nunca. XD.

Bueno, el problema es el siguiente: Necesito ayuda sobre como generar las instrucciones equivalentes: Imaginemos que tengo un:

;En sintaxis FASM
mov [variable], eax
 

Podría ser reemplazado por un:

;En sintaxis FASM
push eax
pop [variable]
 

¿Como podría lograr eso? Tengo una idea, pero no sé si será la mejor opción:

• Analizar el source y el destino
• Aplicar source a un push
• Aplicar destino a un pop

¿Será que alguien me puede dar una idea de como intercambiar las instrucciones? Ya he leído los manuales de Intel bastantes veces, y por lo menos lo básico lo entiendo. Quisiera una ayudadita, porque el tema de los motores metamorficos está algo díficil de implementar.

Gracias a todos de antemano.

Hola, amigos. ¿Como les ha ido? Tengo solo algunos conocimientos sobre el lenguaje C (No conozco mucho sobre C++).

Debido a eso tengo el siguiente problema: Tengo un puntero void que quiero convertir a unsigned char y obtener su valor (todo en la misma linea). Sin embargo, no he podido. ¿Será que alguien me puede ayudar?

Este es el codigo que tratado de hacer (Ya sé que ptr no apunta a ningun lado, pero es solo explicativo):

 
//Intento 1: Al parecer no me da el valor que quiero
void *ptr;
unsigned char temp;
temp = (unsigned char *) &ptr;
 
//Intento 2: El compilador no lo acepta.
void *ptr
unsigned char temp;
temp = (unsigned char) *ptr;
 
 

Ya he buscado por internet, pero no entiendo mucho sobre como hacer lo que expliqué antes. (El tema de los punteros se vuelve un poco enredado. XD).

Se supone que al aplicar * delante de un puntero, él debería devolver su valor. Entonces por qué el compilador no me acepta la segunda opcion???

Gracias a todos de antemano.

Hola, estoy creando un programa que necesita identificar un cierto patron de bits al inicio del byte. Por ejemplo: Si byte comienza con 10100xxx, ir al codigo tal.

Espero que haya explicado bien mi problema. La idea es saber si ciertos bits dentro de un byte están activados, e ignorar el resto. No sé como lograr eso. Quiero lograr comparar, por ejemplo, los primeros cinco bits contra un patron conocido. No quiero identificar solo un bit, quiero identificar un grupo de ellos.

Gracias por su ayuda.

Hola, estoy trabajando en un desensamblador para x86 (32 bits). Ya logré hacer la parte que identifica los prefijos. Pero tengo un problema, ahora estoy en la parte de decodificar los opcodes.

Al principio, he estado pensando en esta idea: Mantener una tabla con los opcodes, y comparar el byte actual contra la tabla. Y según cada caso, tomar la decision apropiada: Por ejemplo leer si hay un byte mod r/m, si tiene SIB, leer desplazamiento e immediate value (haciendo esto tras leer primero el mod r/m).

Y si no coincide con ningun opcode, declarar el byte desde donde se empezó a analizar la instruccion como basura.

Pero, he estado pensando que esa idea puede ser muy ineficiente, ¿será que alguien tiene una mejor manera de hacerlo?

Por ejemplo: En vez de comparar cada byte con una tabla, usar algun principio de generalizacion, por ejemplo: Si los primeros cuatro bits son 1001, es un mov. Luego analizar y determinar el mov especifico correspondiente (mover 8bits/16bits/32bits). ¿Será que es posible? ¿O esa es solo la unica manera?

PD: Ya he estado leyendo algunos sources de programas open source, pero muchos usan esa estrategia, al menos en apariencia. Los estoy leyendo a fondo.

Gracias de antemano.

Hola, estoy desarrollando un desensamblador, para luego integrarle un algoritmo que haga instrucciones equivalentes (motor metamorfico). ¿Será que aún tiene sentido usarlo en estos días, o estaré perdiendo el tiempo?

Estoy desarrollando un malware (solo por diversion. XD). Y no sé si estoy siguiendo los lineamientos correctos al tratar de protegerlo con medidas anti-patrones (para que no sean capaces de conseguir n sucesion de bytes en todos los archivos infectados, algo como 'INFECTED', no debería existir).

Por favor, ayudenme. Denme al menos una respuesta. Gracias por su ayuda.

Hola amigos, tengo un problema. Primero que nada describiré lo que intento hacer: Estoy desarrollando un desensamblador, especificamente este trozo de codigo trata sobre identificar los prefijos que poseen las instrucciones, y guardar en un archivo el prefijo encontrado. Este es un trozo resumido del codigo, y es donde está el problema.

Por ejemplo: Si yo llamo a la funcion show_prefixe(output_file, prefix_cs_override), la funcion trabaja bien, y imprime dentro del fichero la palabra "CS" tal como corresponde según mi tabla.

La funcion trabaja bien con todos los prefijos, excepto con los tres primeros: LOCK, REP y REPNE. No sé porque cuando llamo la funcion con los valores respectivos de cada uno, imprime "UNDEF" (caso por default si no consigue ningun case para ese valor). No entiendo porque toma el caso por default, si existen casos respectivos para cada prefijo (LOCK, REP, y REPNE)

He estado dando vueltas, pero aún no consigo ayuda. Espero que ustedes me ayuden a descifrar este misterioso problema. Aqui va el codigo.

#include <stdio.h>
 
///Prefixes lock and repeat (group one)
 
#define prefix_lock	 0xF0
#define prefix_repne 0xF2
#define prefix_rep 0xF3
 
///Prefixes segmet override (group two)
#define prefix_cs_override		0x2E
#define prefix_ss_override		0x36
#define prefix_ds_override		0x3E
#define prefix_es_override		0x26
#define prefix_fs_override		0x64
#define prefix_gs_override		0x65
 
///Branch hints goes here.
 
///Operand-size override (group three)
#define prefix_operand_size_override	0x66
 
///Address-size override (group four)
#define prefix_address_size_override	0x67
 
 
 
int show_prefixe(FILE *my_output, char prefix){
    switch(prefix){
        case prefix_lock:
            fprintf(my_output, "LOCK ");
            break;
        case prefix_repne:
            fprintf(my_output, "REPNE ");
            break;
        case prefix_rep:
            fprintf(my_output, "REP ");
            break;
        case prefix_ss_override:
            fprintf(my_output, "SS ");
            break;
        case prefix_cs_override:
            fprintf(my_output, "CS ");
            break;
        case prefix_ds_override:
            fprintf(my_output, "DS ");
            break;
        case prefix_es_override:
            fprintf(my_output, "ES ");
            break;
        case prefix_fs_override:
            fprintf(my_output, "FS ");
            break;
        case prefix_gs_override:
            fprintf(my_output, "GS ");
            break;
        case prefix_operand_size_override:
            fprintf(my_output, "OP ");
            break;
        case prefix_address_size_override:
            fprintf(my_output, "ADDR ");
            break;
        default:
            fprintf(my_output, "UNDEF ");
            break;
    }
}
 
int main()
{
    FILE *output;
    output = fopen("C:\\prefix.asm", "wb");
    show_prefixe(output, prefix_rep);
    fclose(output);
    return 0;
}
 
 

¿Será que el compilador tiene bugs? No sé, lo pregunto porque no estoy usando la ultima version, solo estoy usando la previa a la ultima. No sé realmente que ocurre.

Gracias de antemano por su ayuda.