Recientemente utilicé Socket para comunicarme mediante UDP con una PC remota, impelmentando una clase de marcado RAS. Comparto esta solución con ustedes.

Antes de establecer la conexión TCP/IP con el siguiente código, asegúrese de desconectar ActiveSync para evitar fallos.

Archivo de encabezado: RasDialer.h

 1 #if !defined  _RAS_PPP_DIALER_H_  
 2 #define       _RAS_PPP_DIALER_H_  
 3 #if _MSC_VER > 1000  
 4 #pragma once  
 5 #endif // _MSC_VER > 1000  
 6 #include "ras.h"  
 7 class CRasDialer    
 8 {  
 9 private:  
10     LPVOID m_ManeadorMensaje;   
11     HRASCONN m_ConexionRas;  
12     CString m_NombreEntrada;  
13 public:  
14     CRasDialer();  
15     virtual ~CRasDialer();  
16     // Establecer conexión  
17     bool EstablecerConexion(CString Usuario,CString Contraseña);  
18     // Terminar conexión  
19     bool TerminarConexion();  
20     // Configurar manejador de eventos  
21     void ConfigurarManejador(LPVOID _manejador);  
22     bool VerificarConexion(void);  
23     // Obtener estado de conexión mediante mensajes WM_RASDIALEVENT  
24 };  
25 #endif   

Archivo de implementación: RasDialer.cpp

  1 #include "stdafx.h"  
  2 #include "RasDialer.h"  
  3 #include "ras.h"  
  4 #include "Raserror.h"  
  5 #ifdef _DEBUG  
  6 #undef THIS_FILE  
  7 static char THIS_FILE[]=__FILE__;  
  8 #define new DEBUG_NEW  
  9 #endif  
10 //////////////////////////////////////////////////////////////////////  
11 // Constructor/Destructor  
12 //////////////////////////////////////////////////////////////////////  
13 CRasDialer::CRasDialer()  
14 {     
15     m_ConexionRas = NULL;  
16     m_NombreEntrada = L"MiConexion";    // Nombre de la conexión de marcado  
17 }  
18 CRasDialer::~CRasDialer()  
19 {  
20     TerminarConexion();  
21 }  
22 bool CRasDialer::EstablecerConexion(CString Usuario,CString Contraseña)  
23 {  
24     RASDIALPARAMS paramsConexion;    // Parámetros para la conexión  
25     ZeroMemory(&paramsConexion, sizeof(RASDIALPARAMS));  
26     paramsConexion.dwSize = sizeof(RASDIALPARAMS);  
27     wcscpy(paramsConexion.szEntryName, m_NombreEntrada);  
28     wcscpy(paramsConexion.szUserName, Usuario);  
29     wcscpy(paramsConexion.szPassword, Contraseña);   
30     m_ConexionRas = NULL;  
31     DWORD resultado = ::RasDial(NULL, NULL, &paramsConexion, 0xFFFFFFFF, m_ManeadorMensaje , &m_ConexionRas);  
32     if (resultado)   
33     {  
34         return false;  
35     }  
36     return true;  
37 }  
38 bool CRasDialer::TerminarConexion()  
39 {  
40     int indice;                 
41     DWORD error,             
42     tamanioConexion,       
43     numConexiones;    
44     RASCONN conexiones[20];       
45     conexiones[0].dwSize = sizeof (RASCONN);  
46     tamanioConexion = 20 * sizeof (RASCONN);  
47     if (error = RasEnumConnections (conexiones, &tamanioConexion, &numConexiones))  
48     {  
49         return false;  
50     }  
51     if (!numConexiones)  
52     {  
53         return false;  
54     }  
55     for (indice = 0; indice < (int)numConexiones; ++indice)  
56     {  
57         // Evitar cerrar conexiones USB  
58         if (wcsstr(conexiones[indice].szEntryName,_T("MiConexion"))!=NULL)  
59         {  
60             if (error = RasHangUp (conexiones[indice].hrasconn))  
61             {  
62                 return false;  
63             }  
64         }  
65     }  
66     return TRUE;  
67 }  
68 // Configurar manejador de mensajes para recibir eventos de conexión  
69 void CRasDialer::ConfigurarManejador(LPVOID _manejador)  
70 {    
71     m_ManeadorMensaje = _manejador;  
72 }  
73 bool CRasDialer::VerificarConexion(void)  
74 {  
75     if(NULL != m_ConexionRas)  
76     {  
77         RASCONNSTATUS estadoConexion;  
78         estadoConexion.dwSize = sizeof(RASCONNSTATUS);  
79         RasGetConnectStatus(m_ConexionRas,&estadoConexion);  
80         if(RASCS_Connected == estadoConexion.rasconnstate)  
81         {  
82             return true;  
83         }  
84     }  
85     return false;  
86 }  

Verificación de estado de conexión: Implementar un temporizador en la ventana principle.

 1 if(ID_TEMPORIZADOR_RAS == nIDEvento)  
 2     {  
 3         CString csConectando;  
 4     contadorTemporizador++;  
 5         csConectando.Format(L"Conectando (%02d)",contadorTemporizador);  
 6         GetDlgItem(IDC_ESTADOCONEXION)->SetWindowText(csConectando);  
 7         if(m_RasDialer.VerificarConexion())  
 8         {  
 9             RETAILMSG(1,(L"Cliente UDP, Red RAS disponible{%d}/r/n",contadorTemporizador));  
10             KillTimer(nIDEvento);  
11             contadorTemporizador = 0;  
12             csConectando.Format(L"Conexión establecida");  
13             GetDlgItem(IDC_ESTADOCONEXION)->SetWindowText(csConectando);  
14             GetDlgItem(IDC_BOTONABRIR2)->EnableWindow(FALSE);  
15             GetDlgItem(IDC_BOTONABRIR3)->EnableWindow(TRUE);  
16         }  
17         else  
18         {  
19             RETAILMSG(1,(L"Cliente UDP, Red RAS no disponible{%d}/r/n",contadorTemporizador));  
20         }  
21     }  

Uso básico:

1. Establecer conexión: m_RasDialer.EstablecerConexion(L"",L"");
2. Terminar conexión:

1 if(m_RasDialer.VerificarConexion())  
2 {  
3         m_RasDialer.TerminarConexion();  
4 }  

Nota: Este artículo describe únicamente el proceso de establecimiento de conexión TCP/IP. La implementación de comunicación UDP será tratada en una publicación posterior.