Autor Tema: SQLite3 Amalgamation y C: Visor de Archivos y URLs al Azar  (Leído 804 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado ~

  • Trade Count: (0)
  • The Communiter-
  • *
  • Thank You
  • -Given: 0
  • -Receive: 156
  • Mensajes: 1412
    • Ciencia de Computación, OSes y Herramientas
filesopen Espera_aleatoria_minima Espera_aleatoria_maxima Nombre_base_de_datos Numero_de_fila_de_configuracion

Aquí tengo un programa de consola que escribí, que abre automáticamente y al azar archivos locales o URLs tomadas de una base de datos SQLite3 la cual maneja por sí misma usando la librería de Amalgamación de SQLite3.

Está completamente escrita en C y funciona bajo Windows (aunque tal vez pueda funcionar bajo Wine).

Aquí está el binario compilado:
FILESOPEN.EXE

Aquí se puede ver y aprender a escribir un programa en C básico para manejar una base de datos SQLite3:
>> Grabación de Texto para el Visor Aleatorio de Archivos y URLs <<

La estructura documentada y el uso de la base de datos está contenido en dicha grabación de la escritura del código.

Se puede hacer una prueba del funcionamiento con la siguiente base de datos que contiene más de 2 millones de nombres de dominio provenientes de la lista diaria de 1 millón de sitios más importantes de Alexa:
domains_alexaranks.db

Para correr el programa, solo se necesita el siguiente comando:
Código: [Seleccionar]
filesopen 1 1 domains_alexaranks.db 1



Aquí está el código principal (compilado bajo MinGW):
Código: (C) [Seleccionar]
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "SQLite3-Amalgamation-3.12.0/sqlite3.h"
#include "SQLite3-Amalgamation-3.12.0/sqlite3.c"
#include "SQLite3-Amalgamation-3.12.0/sqlite3ext.h"
#include <windows.h>
#include <time.h>

const char sqlite3_version[] = SQLITE_VERSION;


//Some custom function declarations:
///
 unsigned long moreRandomFactor=1;
 unsigned long long_getNumBits(unsigned long num);
 unsigned long stringSum(char *str, unsigned int str_SZ);
 unsigned long getDateMilliseconds(void);
 unsigned long stringToRandomNumber(char *str, unsigned int str_SZ, unsigned long max_rand, unsigned long toRet);



//Set default values for the number of table rows and for the current column
//this last one will be selected at random:
///
 int SQLite3_Row_Ctr=1;
 int SQLite3_Current_Row=1;

 sqlite3      *SQLite3_DB_Obj;
 sqlite3_stmt *SQLite3_State;
 int           SQLite3_DB_Res_Handle;
 char         *SQL_String;
 char         *SQLite3_ErrorMsg=NULL;
 char         *SQLite3_zTail_String;



//These are the default minimum and maximum number of minutes to wait
//before trying to open other file/directory entry:
///
 int minwait=1;
 int maxwait=1;


long minmax_rand(long min, long max)
{
 return rand()%((max+1) - min) + min;
}


char *config_tablename;
char *config_datarowname;
char *config_idrowname;
char *config_fileprotocol;
char *config_mainshell;
int   config_svfskip;
char *config_slashchar;


static int SQLite3_Callback_config(void *NotUsed, int argc, char **argv, char **azColName)
{
 config_tablename=malloc(512);
 config_datarowname=malloc(512);
 config_idrowname=malloc(512);
 config_fileprotocol=malloc(512);
 config_mainshell=malloc(512);
 config_slashchar=malloc(512);

 sprintf(config_tablename,"%s",argv[0]);
 sprintf(config_datarowname,"%s",argv[1]);
 sprintf(config_idrowname,"%s",argv[2]);
 sprintf(config_fileprotocol,"%s",argv[3]);
 sprintf(config_mainshell,"%s",argv[4]);
 config_svfskip=atoi(argv[5]);
 sprintf(config_slashchar,"%s",argv[6]);


 printf("Getting database configuration...\n");
 printf("tablename=%s\ndatarowname=%s\nidrowname=%s\nfileprotocol=%s\nmainshell=%s\nsvfskip=%d\nslashchar=%s\n\n", config_tablename, config_datarowname, config_idrowname, config_fileprotocol, config_mainshell, config_svfskip, config_slashchar);


 return 0;
}



static int SQLite3_Callback(void *NotUsed, int argc, char **argv, char **azColName)
{
 int x=0;
 int requiredSize=0;
 int   openstrlen=0;
 char *cmd=NULL;
 char *cmd2=NULL;
 char *openstr="open";
 char *openstrW;
 char *explorerstr=config_mainshell;
 char *explorerstrW;

 int   execres=0;

 openstrW=malloc(131072);
 explorerstrW=malloc(131072);
 cmd=malloc(131072);
 cmd2=malloc(131072);

 MultiByteToWideChar(
                     (UINT)CP_UTF8,
                     (DWORD)0,
                     (LPCSTR)explorerstr,
                     (int)-1,
                     (LPWSTR)explorerstrW,
                     (int)131072
                    );

 MultiByteToWideChar(
                     (UINT)CP_UTF8,
                     (DWORD)0,
                     (LPCSTR)openstr,
                     (int)-1,
                     (LPWSTR)openstrW,
                     (int)131072
                    );




 for(x=0; x<argc; x++)
 {
  snprintf(cmd,131072,"\"%s%s\"",config_fileprotocol,argv[x]+config_svfskip);
 
  //Try to increase the randomness of the selected row element:
  ///
   moreRandomFactor=stringToRandomNumber(cmd, 131072, SQLite3_Row_Ctr-1, moreRandomFactor);


/*
int MultiByteToWideChar(
  _In_      UINT   CodePage,
  _In_      DWORD  dwFlags,
  _In_      LPCSTR lpMultiByteStr,
  _In_      int    cbMultiByte,
  _Out_opt_ LPWSTR lpWideCharStr,
  _In_      int    cchWideChar
);
*/
  MultiByteToWideChar(
                      (UINT)CP_UTF8,
                      (DWORD)0,
                      (LPCSTR)cmd,
                      (int)-1,
                      (LPWSTR)cmd2,
                      (int)131072
                     );

  printf("%ld: %s\n\n", SQLite3_Current_Row, cmd);

/*
HINSTANCE ShellExecute(
  _In_opt_ HWND    hwnd,
  _In_opt_ LPCTSTR lpOperation,
  _In_     LPCTSTR lpFile,
  _In_opt_ LPCTSTR lpParameters,
  _In_opt_ LPCTSTR lpDirectory,
  _In_     INT     nShowCmd
);

*/

  execres=(int)ShellExecuteW(
                (HWND)0,
                (LPCWSTR)openstrW,
                (LPCWSTR)explorerstrW,
                (LPCWSTR)cmd2,
                (LPCWSTR)NULL,
                (INT)SW_SHOWNORMAL
               );


  switch(execres)
  {
   case 0:
   printf("exec: 0");
   break;

   case ERROR_BAD_FORMAT:
    printf("exec: ERROR_BAD_FORMAT");
   break;

   case SE_ERR_ACCESSDENIED:
    printf("exec: SE_ERR_ACCESSDENIED");
   break;

   case SE_ERR_ASSOCINCOMPLETE:
    printf("exec: SE_ERR_ASSOCINCOMPLETE");
   break;

   case SE_ERR_DDEBUSY:
    printf("exec: SE_ERR_DDEBUSY");
   break;

   case SE_ERR_DDEFAIL:
    printf("exec: SE_ERR_DDEFAIL");
   break;

   case SE_ERR_DDETIMEOUT:
    printf("exec: SE_ERR_DDETIMEOUT");
   break;

   case SE_ERR_DLLNOTFOUND:
    printf("exec: SE_ERR_DLLNOTFOUND");
   break;

   case SE_ERR_FNF:
    printf("exec: SE_ERR_FNF");
   break;

   case SE_ERR_NOASSOC:
    printf("exec: SE_ERR_NOASSOC");
   break;

   case SE_ERR_OOM:
    printf("exec: SE_ERR_OOM");
   break;

   case SE_ERR_SHARE:
    printf("exec: SE_ERR_SHARE");
   break;
  }


  sleep(60*(int)minmax_rand(minwait,maxwait));
 }




 free(cmd);
 free(cmd2);
 free(openstrW);
 free(explorerstrW);


 return 0;
}


static int SQLite3_Callback2(void *NotUsed, int argc, char **argv, char **azColName)
{
 SQLite3_Row_Ctr=atol(argv[0]);
 return SQLite3_Row_Ctr;
}



void clear_state()
{
 //NOTE: This is for the good practice of not leaving
 //      freeing of resources or other default operations
 //      at their default state but accelerate and ensure
 //      the global sanity of the environment and the program
 //      by specifying every operation exactly as we want it:
 ///
 sqlite3_finalize(SQLite3_State);
 sqlite3_close(SQLite3_DB_Obj);
 free(SQL_String);

}






int main(int argc, char *argv[])
{
 atexit(clear_state);
 SQL_String=malloc(4096);



 if(argc>=5)
 {
  if(!(minwait=atoi(argv[1])))minwait=1;
  if(!(maxwait=atoi(argv[2])))maxwait=1;
 }
  else
  {
   printf("Usage: filesopen min_minutes max_minutes SQLITE3_Database_Path Database_Config_ID\n\n");
   return -2;
  }


 //Open the database and see if it was successful. If not, just exit the program:
 ///
  SQLite3_DB_Res_Handle=sqlite3_open(argv[3], &SQLite3_DB_Obj);

  if(SQLite3_DB_Res_Handle!=SQLITE_OK)
  {
   printf("Error opening database\n\n");
   return -1;
  }


  //Get the configuration of the database to use the proper table and field names,
  //as well as basic formatting for the data:
  ///
   snprintf(SQL_String, 4096, "SELECT tablename,datarowname,idrowname,fileprotocol,mainshell,svfskip,slashchar FROM config WHERE configid=%s LIMIT 1", argv[4]);
   SQLite3_DB_Res_Handle=sqlite3_exec(
                                      SQLite3_DB_Obj,
                                      SQL_String,
                                      SQLite3_Callback_config,
                                      SQLite3_zTail_String,
                                      &SQLite3_ErrorMsg
                                     );







 //Get all columns for the first time to count them.
 //Its callback will return the count in SQLite3_Row_Ctr:
 ///
  snprintf(SQL_String, 4096, "SELECT COALESCE(MAX(%s)+1, 0) FROM %s", config_idrowname, config_tablename);
  SQLite3_DB_Res_Handle=sqlite3_exec(
                                     SQLite3_DB_Obj,
                                     SQL_String,
                                     SQLite3_Callback2,
                                     SQLite3_zTail_String,
                                     &SQLite3_ErrorMsg
                                    );

 printf("Cycling through %ld files...\n", SQLite3_Row_Ctr-1);



 while(1)
 {
  //Go to next row (selected randomly):
  ///
   SQLite3_Current_Row=moreRandomFactor;


  //Get random files to open:
  ///
   snprintf(SQL_String, 4096, "SELECT %s FROM %s WHERE %s=%ld LIMIT 1", config_datarowname, config_tablename, config_idrowname, SQLite3_Current_Row);
   SQLite3_DB_Res_Handle=sqlite3_exec(
                                      SQLite3_DB_Obj,
                                      SQL_String,
                                      SQLite3_Callback,
                                      SQLite3_zTail_String,
                                      &SQLite3_ErrorMsg
                                     );


  //If there was a database error or fault, just end:
  ///
   if(SQLite3_ErrorMsg)return 0;
 }


 return 0;
}



unsigned long long_getNumBits(unsigned long num)
{
 unsigned long toRet=0;
 while(num)
 {
  num>>=1;
  toRet++;
 }

 return toRet;
}



unsigned long stringSum(char *str, unsigned int str_SZ)
{
 int x=0;
 unsigned long toRet=0;
 for(x=0; x<str_SZ; x++)
 {
  toRet+=x;
  toRet+=(int)str[x];
 }


 return toRet;
}


unsigned long getDateMilliseconds(void)
{
 return clock();
}



unsigned long stringToRandomNumber(char *str, unsigned int str_SZ, unsigned long max_rand, unsigned long toRet)
{
 unsigned long x=0;
 toRet+=minmax_rand(1, max_rand);


 for(x=0; x<str_SZ; x++)
 {
  toRet+=x;
  toRet+=getDateMilliseconds();
  toRet+=(unsigned long)str[x];
  if(toRet>max_rand)toRet&=minmax_rand(1, max_rand);
 }

 if(toRet==0)toRet++;
 return toRet;
}




Estructura de base de datos:
Código: [Seleccionar]
CREATE TABLE files(file TEXT NOT NULL UNIQUE, id INTEGER PRIMARY KEY AUTOINCREMENT);
pragma encoding="UTF-8";

.mode line
.import files.txt files


CREATE TABLE config(
                    tablename TEXT NOT NULL,
                    datarowname TEXT NOT NULL,
                    idrowname TEXT NOT NULL,
                    fileprotocol TEXT NOT NULL,
                    mainshell TEXT NOT NULL,
                    svfskip INTEGER NOT NULL,
                    slashchar TEXT NOT NULL,
                    configid INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL
                   );



<b>Configuration for regular file listing databases:</b>
INSERT INTO config values("files","file","id","","C:\\WINDOWS\\explorer.exe",0,"",NULL);
INSERT INTO config values("files","file","id","","C:\\WINDOWS\\explorer.exe",0,"\\",NULL);


<b>Configuration for Geocities distribution databse:</b>
INSERT INTO config values("files","file","id","","C:\\WINDOWS\\explorer.exe",130,"",NULL);
INSERT INTO config values("files","file","id","","C:\\WINDOWS\\explorer.exe",130,"/",NULL);


<b>Configuration for Alexa URL listing database:</b>
INSERT INTO config values("domains_alexaranks","domain","domain_id","http://","C:\\WINDOWS\\explorer.exe",0,"",NULL);


« Última Modificación: abril 04, 2016, 05:09:52 pm por ~ »
Mi sitio web:
---- IP para archivo hosts (todos mis subdominios):
190.150.9.244 archefire.org

Desconectado pinocchio

  • Trade Count: (0)
  • Sv Member
  • ***
  • Thank You
  • -Given: 5
  • -Receive: 4
  • Mensajes: 122
Re:SQLite3 Amalgamation y C: Visor de Archivos y URLs al Azar
« Respuesta #1 : abril 04, 2016, 01:10:13 pm »
......