Descargar lpthandler.tar

lpthandler.exe 3bc 11111111

   o sino el puerto 378
lpthandler.exe 378 11111111

   o sino el puerto 278
lpthandler.exe 278 11111111

lpthandler.exe 3bc 00000000

   o sino el puerto 378
lpthandler.exe 378 00000000

   o sino el puerto 278
lpthandler.exe 278 00000000

/*
 En resumen solo necesitamos:
 
  Out32(Direccion_Base_Puerto_Paralelo+2, 0);          //Resetear Puerto de Control
  Out32(Direccion_Base_Puerto_Paralelo,   0xFF-0x00);  //Escribir el Puerto de Datos
*/
 
 
 
//Aquí, la Direccion_Base_Puerto_Paralelo
//puede ser:
//          0x3BC -- LPT1
//          0x378 -- LPT1
//          0x278 -- LPT2
///
 
//Necesitamos resetear el Puerto de Control escribiéndole un 0
//para configurar sus opciones, controladas por cada uno de
//sus bits:
///
  Out32(Direccion_Base_Puerto_Paralelo+2, 0);
 
//Enviamos un valor entre 0 y 255 al puerto de Datos:
///
  Out32(Direccion_Base_Puerto_Paralelo,   0xFF-0x00);
 

>> Ver Tutorial Animado de Código de lpthandler.c <<

Out32(378h, 255-0);

//NOTE: Compile with GCC under MinGW.
//
// gcc lpthandler.c -o lpthandler.exe
//
//Usage:
// lpthandler.exe LPT_Port Byte_Bit_Data
//
// LPT_Port:
//  - can be 3bc, 378 or 278
//
// Byte_Bit_Data:
//  - can range from 00000000 to 11111111 (written like that, in binary).
//    Every bit controls one of 8 LEDs.
//
// LEDs are connected between DATA and GROUND lines.
// DATA to GROUND lines are connected like this, for pins:
//
// DATA is + and GROUND is -
//
//  2-18
//  3-19
//  4-20
//  5-21
//  6-22
//  7-23
//  8-24
//  9-25
//
// Remember to set the parallel ports as Standard/Normal in the BIOS
// to ensure proper working of the basics with this program.
///
 
#include <stdio.h>
#include <windows.h>
 
typedef short _stdcall (*_Out32)(short portaddr, short value);
typedef short _stdcall (*_Inp32)(short portaddr);
 
int main(int argc, char *argv[])
{
 HINSTANCE INPOUT32_DLL_Handle;
 _Inp32 Inp32;
 _Out32 Out32;
 
 
 //Load the inpout32.dll library. It's also associated
 //with hwinterface.sys, but it should open it by itself:
 ///
  INPOUT32_DLL_Handle=LoadLibrary("inpout32.dll");
  if(INPOUT32_DLL_Handle == NULL)
  {
   printf("LoadLibrary failed for inpout32.dll...\n\n");
   return -1;
  }
 
 
 //Get access to the Out32/Inp32 functions from inpout32.dll:
 ///
  Out32 = (_Out32)GetProcAddress(INPOUT32_DLL_Handle, "Out32");
  Inp32 = (_Inp32)GetProcAddress(INPOUT32_DLL_Handle, "Inp32");
 
 //NOTE: The following two lines are the actual logic of the program
 //      and are at the top of importance and the program's key logic.
 //      Everything else could be considered API noise:
 
 //Configure the CONTROL Port with a 0 to sanitize the port state:
 ///
  Out32(strtol(argv[1],NULL,16)+2, 0);  //Bit 0: Strobe
                                        //Bit 1: Auto Line Feed
                                        //Bit 2: Initialize Printer
                                        //Bit 3: Select Printer
                                        //Bit 4: Enable IRQ Via Ack Line
                                        //Bit 5: Enable Bi-Directional Port
                                        //Bit 6: Unused
                                        //Bit 7: Unused
 
 
 
 //Write the Data port with the desired 8-bit value:
 ///
  Out32(strtol(argv[1],NULL,16), strtol(argv[2],NULL,2));
 
 
 //Unload our inpout32.dll library:
 ///
  FreeLibrary(INPOUT32_DLL_Handle);
 
 return 0;
}
 
 

filesopen 1 1 domains_alexaranks.db 1

#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>
 
const char sqlite3_version[] = SQLITE_VERSION;
 
//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;
 
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);
 
 sprintf(config_tablename,"%s",argv[0]);
 sprintf(config_datarowname,"%s",argv[1]);
 sprintf(config_idrowname,"%s",argv[2]);
 sprintf(config_fileprotocol,"%s",argv[3]);
 
 
 printf("Getting database configuration...\n");
 printf("tablename=%s\ndatarowname=%s\nidrowname=%s\nfileprotocol=%s\n\n", config_tablename, config_datarowname, config_idrowname, config_fileprotocol);
 
 
 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="C:\\WINDOWS\\explorer.exe";
 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]);
 
/*
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 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);
 
 
 while(1)
 {
  //Go to next row (selected randomly):
  ///
   SQLite3_Current_Row=minmax_rand(1, SQLite3_Row_Ctr);
 
 
  //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;
}