Imprimir Página - Re: Comunicación Por Sockets

Programación General => C/C++ => Mensaje iniciado por: captaindanieo en Domingo 2 de Diciembre de 2007, 14:08

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Domingo 2 de Diciembre de 2007, 14:08

Buenos dias. Últimamente todo son problemas en el trabajo que estoy programando, y no acabo de salir de uno cuando me encuentro en otro todavía mas grande.

Antes de nada darle las gracias a Eternal Idol, por todas las respuestas y ayudas en los posts que he ido posteando estos dias atrás, y que sin duda me han ayudado a seguir adelante. Muchísimas gracias.

Mi programa, se distribuye en varias partes. El objetivo es implementar una capa de protocolo, y para ello, he hecho uso de las clases.

Mi clase L2cap, es la clase de mi capa que quiero implementar. Y dentro de ella, se hace uso de otra clase, que es la clase L2capChannel. Cuando dos instancias de L2cap establecen una comunicación entre ellas, crean un canal L2capChannel, y establecen una comunicación por socket.

Para los sockets he usado una clase que ya había implementada. Con lo cual hago uso de ella para dicha comunicación.

Los sockets los tengo en la clase L2cap, y cuando envío o recibo datos desde L2cap funciona sin problema aparente. (Es decir, si desde L2cap hago una llamada a sendRaw por ejemplo, se transmite el mensaje creado en sendRaw por el socket y llega a la otra entidad de mi programa).

La cosa es que yo necesito también que el L2capChannel, en algún momento determinado, como por ejemplo cuando reciba un mensaje de datos que sea una ConnectionRequest, deba enviar él otro mensaje que sea una ConnectionResponse. Y por tanto, para dicho envío, ha de hacer uso de los sockets. Por lo tanto, el canal debería de poder también enviar por el socket.

Primeramente pensé en pasarle en el constructor de L2capChannel, un puntero al socket. De manera que pudiese escribir din problemas. Sin embargo no funciona. Y no se por qué, porque revisé todo y debería de haber funcionado.

Otra alternativa que pensé fue en hacerlo mediante callbacks, que es la que actualmente tengo implementada (el constructor de L2capChannel en el caso de pasarle el puntero a socket lo tengo entre comentarios, y ahora solo uso el de callback). Sin embargo el resultado es el mismo.

Y ya no se que mas puedo hacer. He intentado hacerlo de todas las maneras posibles, pero llevo semanas atascado en dicha comunicación y no hay manera. :(

La ejecución del programa ha de hacerse de la siguiente manera:
Primero ejecuto, y elijo la opción 1, que es el modo Servidor. De esa manera habrá alguien escuchando en el puerto.

Seguidamente, ejecuto el programa de nuevo, dejando el otro abierto, y ésta vez, elegimos la opción 2, que es el modo cliente. Ésto provocará que a la hora de crear mi nueva capa L2cap lo haga de forma diferente (como cliente).
Y después de crear mi capa, llama a la primitiva de L2cap OpenChannelReq.

Tanto en el caso del Servidor como del Cliente, he colocado un bucle infinito para que no finalice la ejecución del programa, y en dicho bucle saca un mensaje por pantalla.

OpenChannel se encarga de abrir un nuevo canal para una comunicación. Para ello busca un CID (identificador de canal) libre, y crea un nuevo L2capChannel, introduciéndolo en el vector de canales, y construyendo dicho canal mandándole mediante callback la funcion que usará el canal para enviar datos por el socket (ya que el socket está en L2cap y no en L2capChannel).

Seguidamente actualiza también el vector tabla, que es simplemente un registro de los canales que han sido creados en mi capa L2cap.

Y finalmente, se hace una llamada a ese canal creado en el vector, a su procedimiento connectChannel().

[connect channel, provocaría la elaboración de una Connection Request, la almacenaria en variables globales, pasaría dichas variables a un array de salida, crearia una string con el contenido a mandar, y la tendría que mandar por el socket]

Sin embargo, en lugar de toda esta secuencia de acciones, para testear la comunicación por el socket, en el mismo constructor del canal L2capChannel, he puesto que se llame al Wrapper a la función que escribe en el socket en L2cap. He puesto que escriba una cadena de caracteres, que resulta que es una ConnectionRequest.

La llamada al Wrapper se realiza perfectamente, ya que se muestra por pantalla que se ha entrado en dicha función.

Pero por el socket no se escribe nada. El Servidor debería de recibir la cadena por el socket, y no la recibe.

El cliente muestra que se ha creado un canal, muestra el contenido de la tabla, y dice que ha enviado por el socket una cadena, pero al Servidor no le llega.

Se que quizás sea muy extenso el código, he intentado reducirlo al máximo dejando solo lo indispensable para ver el problema de la comunicación por socket.
Muchísimas gracias por todo.

Pongo el código a continuación de cada uno de los archivos, comenzando por la clase Socket, seguida de los archivos de mi programa.

Muchas gracias.

-----------------------------| socket.h |--------------------

Código: Text

#ifndef SOCKET_H
#define SOCKET_H
 
#include &#60;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h&#62;
#include &#60;string&#62;
 
enum TypeSocket {BlockingSocket, NonBlockingSocket};
 
class Socket {
    public:
    
      virtual ~Socket();
      Socket(const Socket&);
      Socket& operator=(Socket&);
    
      std::string ReceiveLine();
      std::string ReceiveBytes();
    
      void   Close();
    
      // The parameter of SendLine is not a const reference
      // because SendLine modifes the std::string passed.
      void   SendLine (std::string);
    
      // The parameter of SendBytes is a const reference
      // because SendBytes does not modify the std::string passed 
      // (in contrast to SendLine).
      void   SendBytes(const std::string&);
    
    protected:
      friend class SocketServer;
      friend class SocketSelect;
    
      Socket(SOCKET s);
      Socket();
    
    
      SOCKET s_;
    
      int* refCounter_;
    
    private:
      static void Start();
      static void End();
      static int  nofSockets_;
 
};
 
 
class SocketClient : public Socket 
{
    public:
      SocketClient(const std::string& host, int port);
};
 
 
 
class SocketServer : public Socket 
{
    public:
      SocketServer(int port, int connections, TypeSocket type=BlockingSocket);
    
      Socket* Accept();
};
 
 
// http: //msdn.microsoft .com/library/default.asp?url=/library/en-us/winsock/wsapiref_2tiq.asp
class SocketSelect {
  public:
    SocketSelect(Socket const * const s1, Socket const * const s2=NULL, TypeSocket type=BlockingSocket);
 
    bool Readable(Socket const * const s);
 
  private:
    fd_set fds_;
}; 
 
 
#endif
 
 

-----------------------------| socket.cpp |--------------------

Código: Text

#include &#60;SOCKET.h&#62;
#include &#60;iostream&#62;
 
using namespace std;
 
 
int Socket::nofSockets_= 0;
 
 
void Socket::Start() 
{
  if (!nofSockets_) 
  {
    WSADATA info;
    if (WSAStartup(MAKEWORD(2,0), &info)) 
    {
      throw &#34;Could not start WSA&#34;;
    }
  }
  ++nofSockets_;
}
 
 
void Socket::End() 
{
  WSACleanup();
}
 
 
Socket::Socket() : s_(0) 
{
  Start();
  // UDP: use SOCK_DGRAM instead of SOCK_STREAM
  s_ = socket(AF_INET,SOCK_STREAM,0);
 
  if (s_ == INVALID_SOCKET) 
  {
    throw &#34;INVALID_SOCKET&#34;;
  }
 
  refCounter_ = new int(1);
}
 
 
Socket::Socket(SOCKET s) : s_(s) 
{
  Start();
  refCounter_ = new int(1);
};
 
 
Socket::~Socket() 
{
  if (! --(*refCounter_)) 
  {
    Close();
    delete refCounter_;
  }
 
  --nofSockets_;
  if (!nofSockets_) End();
}
 
 
Socket::Socket(const Socket& o) 
{
  refCounter_=o.refCounter_;
  (*refCounter_)++;
  s_         =o.s_;
 
  nofSockets_++;
}
 
 
Socket& Socket::operator=(Socket& o) 
{
  (*o.refCounter_)++;
 
  refCounter_=o.refCounter_;
  s_         =o.s_;
 
  nofSockets_++;
 
  return *this;
}
 
 
void Socket::Close() 
{
  closesocket(s_);
}
 
 
std::string Socket::ReceiveBytes() 
{
  std::string ret;
  char buf[1024];
 
  while (1) {
    u_long arg = 0;
    if (ioctlsocket(s_, FIONREAD, &arg) != 0)
    {
      break;
    }
 
    if (arg == 0)
    {
      break;
    }
    
    if (arg &#62; 1024)
    {
            arg = 1024;
    }
 
    int rv = recv (s_, buf, arg, 0);
 
    if (rv &#60;= 0)
    {
           break;
    }
 
    std::string t;
 
    t.assign (buf, rv);
    ret += t;
  }
 
  return ret;
}
 
 
std::string Socket::ReceiveLine() 
{
  std::string ret;
  while (1) 
  {
    char r;
 
    switch(recv(s_, &r, 1, 0)) 
    {
      case 0: // not connected anymore;
              // ... but last line sent
              // might not end in &#092;n,
              // so return ret anyway.
        return ret;
 
      case -1:
        return &#34;&#34;;
//      if (errno == EAGAIN) {
//        return ret;
//      } else {
//      // not connected anymore
//      return &#34;&#34;;
//      }
    }
 
    ret += r;
    if (r == '&#092;n')  return ret;
  }
}
 
 
void Socket::SendLine(std::string s) 
{
  s += '&#092;n';
  send(s_,s.c_str(),s.length(),0);
}
 
 
void Socket::SendBytes(const std::string& s) 
{
  send(s_,s.c_str(),s.length(),0);
}
 
 
SocketServer::SocketServer(int port, int connections, TypeSocket type) 
{
  sockaddr_in sa;
 
  memset(&sa, 0, sizeof(sa));
 
  sa.sin_family = PF_INET;             
  sa.sin_port = htons(port);          
  s_ = socket(AF_INET, SOCK_STREAM, 0);
  if (s_ == INVALID_SOCKET) 
  {
    throw &#34;INVALID_SOCKET&#34;;
  }
 
  if(type==NonBlockingSocket) 
  {
    u_long arg = 1;
    ioctlsocket(s_, FIONBIO, &arg);
  }
 
  /* bind the socket to the internet address */
  if (bind(s_, (sockaddr *)&sa, sizeof(sockaddr_in)) == SOCKET_ERROR) 
  {
    closesocket(s_);
    throw &#34;INVALID_SOCKET&#34;;
  }
  
  listen(s_, connections);                               
}
 
 
Socket* SocketServer::Accept() 
{
  SOCKET new_sock = accept(s_, 0, 0);
  if (new_sock == INVALID_SOCKET) 
  {
    int rc = WSAGetLastError();
    if(rc==WSAEWOULDBLOCK) 
    {
      return 0; // non-blocking call, no request pending
    }
    else 
    {
      throw &#34;Invalid Socket&#34;;
    }
  }
 
  Socket* r = new Socket(new_sock);
  return r;
}
 
 
SocketClient::SocketClient(const std::string& host, int port) : Socket() 
{
  std::string error;
 
  hostent *he;
  if ((he = gethostbyname(host.c_str())) == 0) 
  {
    error = strerror(errno);
    throw error;
  }
 
  sockaddr_in addr;
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr = *((in_addr *)he-&#62;h_addr);
  memset(&(addr.sin_zero), 0, 8); 
 
  if (::connect(s_, (sockaddr *) &addr, sizeof(sockaddr))) 
  {
    error = strerror(WSAGetLastError());
    throw error;
  }
}
 
 
SocketSelect::SocketSelect(Socket const * const s1, Socket const * const s2, TypeSocket type) 
{
  FD_ZERO(&fds_);
  FD_SET(const_cast&#60;Socket*&#62;(s1)-&#62;s_,&fds_);
  if(s2) 
  {
    FD_SET(const_cast&#60;Socket*&#62;(s2)-&#62;s_,&fds_);
  }     
 
  TIMEVAL tval;
  tval.tv_sec  = 0;
  tval.tv_usec = 1;
 
  TIMEVAL *ptval;
  if(type==NonBlockingSocket) 
  {
    ptval = &tval;
  }
  else 
  { 
    ptval = 0;
  }
 
  if (select (0, &fds_, (fd_set*) 0, (fd_set*) 0, ptval) == SOCKET_ERROR) 
    throw &#34;Error in select&#34;;
}
 
bool SocketSelect::Readable(Socket const* const s) 
{
  if (FD_ISSET(s-&#62;s_,&fds_)) return true;
  return false;
}
 
 

-----------------------------| tipos.h |--------------------

Código: Text

//                              DEFINICION DE TIPOS
 
typedef unsigned int Tpdu_L2CAP [1200]; // Dato de entrada, PDU L2CAP  
 
 
 
typedef struct {
  unsigned int Code;
  unsigned int ID;
  int Length;
  int PSM;
  int SCID;
} TL2CAP_con_req;    // Connection Request packet
 
typedef struct {
  unsigned int Code;
  unsigned int ID;
  int Length;
  int DCID;
  int SCID;
  int Result;
  int Status;
} TL2CAP_con_res;   // Connection Response packet
 
 

-----------------------------| constantes.h |--------------------

Código: Text

// Codigos de los comandos de señalizacion
 
#define L2CAP_CONREQ 0x02
#define L2CAP_CONRES 0x03
 
 
// Estados definidos en la máquina de estados
 
#define CLOSED 0x00
#define WAIT_CONNECT 0x01
#define WAIT_CONNECT_RSP 0x02
#define CONFIG 0x03   // Consta de un numero de sub estados
#define OPEN 0x04
#define WAIT_DISCONNECT 0x05
 
// Sub estados dentro del estado CONFIG
 
#define WAIT_CONFIG 0x06
#define WAIT_SEND_CONFIG 0x07
#define WAIT_CONFIG_REQ_RSP 0x08
#define WAIT_CONFIG_RSP 0x09
#define WAIT_CONFIG_REQ 0x10
 
// Eventos
 
#define OPENCHANNEL_REQ 0x01
#define OPENCHANNEL_RSP 0x02
#define CONNECTREQ 0x03
#define CONNECTRSP 0x04
 
 

-----------------------------| principal.cpp |--------------------

Código: Text

#include &#60;cstdlib&#62;
#include &#60;iostream&#62;
#include &#60;L2cap.h&#62;
#include &#60;windows.h&#62;
 
using namespace std;
 
 
int main()
{
  int msg,opcion;
  std::string cadena;
    msg = 0;
    
    do 
  { 
    system(&#34;cls&#34;);
    opcion = 0;
    cout &#60;&#60;endl&#60;&#60;&#34;                *-----------------------------------------*&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |        B  L  U  E  T  O  O  T  H        |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                *-----------------------------------------*&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |       M E N U   L 2 C A P   v 2.1.      |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                *-----------------------------------------*&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |                                         |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |  1.- Modo Servidor................. (1) |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |  2.- Modo Cliente manda PDU........ (2) |&#34;;
        cout &#60;&#60;endl&#60;&#60;&#34;                |  3.- Salir......................... (3) |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                |                                         |&#34;;
    cout &#60;&#60;endl&#60;&#60;&#34;                *-----------------------------------------*&#34;&#60;&#60;endl&#60;&#60;endl&#60;&#60;endl;
    cout &#60;&#60;endl&#60;&#60;&#34;                  &#62;  Elija una Opcion.......... &#34;;
    scanf(&#34;%d&#34;,&opcion);
 
  }while (opcion &#60; 1 || opcion &#62; 3);
 
  //Lee Menu y llama funciones
  switch(opcion)
    {             
         case 1: 
             {
              system(&#34;cls&#34;);
              L2cap micapa(1);
              while (1)
              {
                    cout&#60;&#60;&#34;Sigo aqui en modo Servidor...&#34;&#60;&#60;endl;
                    Sleep(4000);  
                }
                break;
             }
 
         case 2: 
             {
              system(&#34;cls&#34;);
              L2cap micapa(2);
                
                micapa.Openchannel_req ();
                
                //micapa.sendRaw();  
                // Si utilizo sendRaw desde aquí, SI funciona la comunicación
                //por Socket de client a Serv, pero no de Serv a cliente (el canal no escribe por socket)
                
                while (1)
                {
                   cout&#60;&#60;&#34;Sigo aqui en modo Cliente...&#34;&#60;&#60;endl;
                   Sleep(4000);  
                 }
              system(&#34;pause&#34;);
              break;
             }
    
        case 3: 
            {
                system(&#34;cls&#34;);
              L2cap micapa(3);                
                micapa.Salir();
                cout &#60;&#60;endl&#60;&#60;&#34;                &#62;  FIN DEL PROGRAMA..........&#34;&#60;&#60;endl&#60;&#60;endl;
            break;
        }
    }
  return 0;
}  
 
 

-----------------------------| l2cap.h |--------------------

Código: Text

//#include &#60;Socket.h&#62;
#include &#60;L2capChannel.h&#62;
#include &#60;vector&#62;
#include &#60;string&#62;
#include &#60;sstream&#62;
#include &#60;iostream&#62;
#include &#60;cstdlib&#62;
#include &#60;stdio.h&#62;
#include &#60;stdlib.h&#62;
 
using namespace std;
 
 
                   // DEFINICION DE TIPOS
 
typedef struct 
{
    unsigned int CID;
  unsigned int PSM;
  int funcptr;
} Ttabla;
 
 
typedef L2capChannel *Tpcanal;
 
 
 
class L2cap
{
 
 public:
        
     L2cap (int mode);  // Constructor.
     ~L2cap (); // Destructor.
     void Salir ();    
     void Send_Data(std::string cadena); // Modo Cliente        
     void Server(int argc, char* argv[]); // Modo Servidor
     void leerSocketClient();
     void leerSocketServer();
     void leerSocket();
     void sendRaw();
     bool escuchando();
 
     void escribeEnSocket(std::string cadena);
     static void Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena);
 
 
     int Openchannel_req ();
 
 
 private:     
                       // VARIABLES GLOBALES
     Socket *s;
     bool _escuchando;
     vector&#60;Ttabla&#62; tabla;
     vector&#60;L2capChannel*&#62; canales;
     
      
                         //     FUNCIONES
 
        void string_to_bytearray (std::string str, unsigned int* &array, int& size);
 
        unsigned int Leertipotrama (Tpdu_L2CAP datain);
        static unsigned __stdcall bucleLectura(void* a);
        void Analiza_contenido(std::string r);
        int BuscaTabla(int cid);
        void ImprimeTabla();
        int AsignaCID(void);
};
 
 

-----------------------------| l2cap.cpp |--------------------

Código: Text

#include &#60;L2cap.h&#62;
#include &#60;Socket.h&#62;
#include &#60;vector&#62;
#include &#60;process.h&#62;
#include &#60;string&#62;
#include &#60;sstream&#62;
#include &#60;iostream&#62;
#include &#60;cstdlib&#62;
#include &#60;stdio.h&#62;
 
using namespace std;
 
 
bool L2cap::escuchando()
{
     return _escuchando;
}
 
 
unsigned __stdcall L2cap::bucleLectura(void* a) 
{
  L2cap *thisL2cap = (L2cap*)a;
    
  while (thisL2cap-&#62;escuchando())
  {
    cout&#60;&#60;endl&#60;&#60;&#34;Esperando Nuevos datos...&#34;&#60;&#60;endl;
    thisL2cap-&#62;leerSocket();
  }
  return 0;
}
 
 
L2cap::L2cap (int mode)  // Constructor
{
   _escuchando = true;
 
   if (mode==1) // Modo Servidor
   {
   SocketServer in(3000,5);
   Socket* sa=in.Accept();
   s = sa;
   cout&#60;&#60;&#34;Conexion Recibida&#34;&#60;&#60;endl;      
 
   unsigned ret;
   _beginthreadex(0,0,bucleLectura,(void*)this,0,&ret);
   }
 
   else if (mode==2) // Modo Cliente
   {
   SocketClient sb(&#34;pc.&#34;, 3000);
   s = &sb;
   *(s) = sb; //Con esto hemos anclado el contenido del puntero y ya no se borra al salir del Constructor
 
 
   unsigned ret;
   _beginthreadex(0,0,bucleLectura,(void*)this,0,&ret);
   }
} //Ctor
 
 
 
L2cap::~L2cap ()  // Destructor
{
}
 
 
 
void L2cap::string_to_bytearray(std::string str, unsigned int* &array, int& size)
{
  int length = str.length();
  // nos aseguramos de que la cadena entrante tiene un número de elementos par
  if(length%2 == 1)
  {
    str = &#34;0&#34; + str;
    length++;
  }
  // Reservamos memoria para el array de salida  
  array = new unsigned int[length/2];
  size = length/2;
 
  std::stringstream sstr(str);
 
  for(int i=0; i &#60; size; i++)
  {
    char ch1, ch2;
    sstr &#62;&#62; ch1 &#62;&#62; ch2;
    unsigned int dig1, dig2;
    if(isdigit(ch1)) dig1 = ch1 - '0';
    else if(ch1&#62;='A' && ch1&#60;='F') dig1 = ch1 - 'A' + 10;
    else if(ch1&#62;='a' && ch1&#60;='f') dig1 = ch1 - 'a' + 10;
    if(isdigit(ch2)) dig2 = ch2 - '0';
    else if(ch2&#62;='A' && ch2&#60;='F') dig2 = ch2 - 'A' + 10;
    else if(ch2&#62;='a' && ch2&#60;='f') dig2 = ch2 - 'a' + 10;
    array[i] = dig1*16 + dig2;
  }
}
 
 
 
unsigned int L2cap::Leertipotrama(Tpdu_L2CAP datain)    
{
  unsigned int tipo;
 
  if ((*(datain+2)==0x01)&(*(datain+3)==0x00))   
  {
    tipo = 'C'; // Trama de control. c-frame
  }
  else if ((*(datain+2)==0x02)&(*(datain+3)==0x00))
  {
    tipo = 'G'; // Trama G. Canal no orientado a conexión
  }
  else if ((*(datain+2)&#62;=0x40))
  {
    tipo = 'B';  // Trama-B
  }
  else
  {
    tipo = 'N'; // Tipo no válido
  }
  return tipo;
}
 
 
void L2cap::Salir () // Funcion que manda por socket la cadena salir que hace que salga del bucle infinito Server
{
   int i;
   
   SocketClient s(&#34;pc.&#34;, 3000); //No hace falta crear el socket de nuevo
   std::string c1 = &#34;exit&#34;;
   s.SendBytes(c1);
}
 
 
int L2cap::BuscaTabla(int cid)
{
    int bus=-1;
    for (int i=0; i&#60;tabla.size();i++)
    {
        if (tabla[i].CID==cid)
        {
           bus=i;
        }
    }
    return bus;
    //Si no ha encontrado registrado en la tabla el CID buscado, devuelve -1,
    //En caso de q lo encuentre, devuelve la posicion en la que se encuentra el
    //canal con dicho CID
}
 
 
void L2cap::ImprimeTabla()
{
    printf(&#34;&#092;n&#092;n----TABLA DE REGISTRO DE CANALES L2CAP----&#092;n&#34;);
    for (int i=0; i&#60;tabla.size();i++)
    {
        printf(&#34;tabla [%d].CID = %X &#092;n&#34;,i,tabla[i].CID);
        printf(&#34;tabla [%d].PSM = %X &#092;n&#092;n&#34;,i,tabla[i].PSM);
    }
}
 
 
 
int L2cap::AsignaCID() 
//Busca, para una trama de datos (B), que CID hay libre para asignarle
//a la comunicación actual
{
    int nuevoCID=0x40;
    while (BuscaTabla(nuevoCID)&#62;=0)
    {
          printf(&#34;Ya esta registrado el CID de valor %X &#092;n&#34;,nuevoCID);
          nuevoCID++;
    }
    printf(&#34;Registrado con exito el CID de valor %X &#092;n&#34;,nuevoCID);
    return nuevoCID; //Devuelve el 1ero que no esta en la tabla
}
 
 
void L2cap::Analiza_contenido(std::string r)
{
    unsigned int longitud, tipo;
     unsigned int* datain = NULL;
    int size,CID,bus,num;
 
    size = r.length();
    if (size&#62;0)
    {   
      if (r ==&#34;exit&#34;)
      {
          _escuchando = false;
          cout&#60;&#60;&#34;Escuchando se ha puesto a false&#34;&#60;&#60;endl;
      }
      else
      {
          cout &#60;&#60;&#34;Recibida una string de longitud &#34;&#60;&#60;r.length()&#60;&#60;endl&#60;&#60;&#34;y contenido: &#34;&#60;&#60;r&#60;&#60;endl&#60;&#60;endl;                
          string_to_bytearray(r,datain,size);
          
          longitud = size-4; // se trata del campo length, mientras q size es toda.
        
          tipo = Leertipotrama (datain);
        
          switch (tipo)
            {
            case 'C' :  // Se trata de una trama-C
              {     
                printf(&#34;Es una trama C &#092;n &#092;n&#34;);
                     // Primero vemos de que comando se trata
                           int code = *(datain+4);
                           
                           if (code==L2CAP_CONREQ)
                           {
                             //Creamos un canal nuevo, actualizamos tabla,...
                           int receivedPSM = *(datain+8) + (*(datain+9))*256;
                             CID = AsignaCID(); //Asignamos nuevo CID
                             cout&#60;&#60;&#34;Recibida Connection Request&#34;&#60;&#60;endl;
 
                             canales.push_back(new L2capChannel(CID,receivedPSM,s)); //puntero a socket
                             Ttabla elementoTabla;
                             elementoTabla.CID = CID;
                             elementoTabla.PSM = receivedPSM;
                             tabla.push_back(elementoTabla);
                             ImprimeTabla();
                           }
                           
                           else
                           //Se trata de una: ConnectionRsp, ConfigReq,
                           //ConfigRsp*, DiscReq
                           {
                               CID = *(datain+8) + (*(datain+9))*256;
                           }
                        
                        bus=BuscaTabla(CID);
                        if (bus &#62;=0)
                        {
                           num=canales[bus]-&#62;entradaComandos(datain,longitud);
                        }
 
                    break;
                    }
        
            case 'G' :  // Se trata de una trama-G
              {
                    printf(&#34;Es una trama G &#092;n &#092;n&#34;);    
              break;
              }
        
            case 'B' : //Se trata de una trama-B
              {
                        printf(&#34;Es una trama B &#092;n &#092;n&#34;);
                  break;
              }
                 
                case 'N': 
              {
              printf(&#34;Trama no valida. &#092;n &#092;n&#34;);
                  break;
              }
                
                default :
              {
                printf(&#34;Algo esta pasando... &#092;n &#092;n&#34;);
              }
               }        
      }       
    }
}
 
 
 
 
void L2cap::leerSocket()
{
     cout&#60;&#60;&#34;Voy a leer&#34;&#60;&#60;endl;
 
     std::string r = &#34;&#34;;
     while (r.length()==0)
     {
       r = s-&#62;ReceiveBytes();
     }
     Analiza_contenido(r);    
     cout&#60;&#60;&#34;Ya he leido&#34;&#60;&#60;endl;
}
 
 
 
void L2cap::sendRaw()
{
    std::string cadena=&#34;080001000205040001004000&#34;; //Connection Request     
    escribeEnSocket(cadena);
    cout&#60;&#60;&#34;He enviado una cadena&#34;&#60;&#60;endl;
}
 
 
int L2cap::Openchannel_req ()
{
    int res = 0;
    int PSM = 2;
    int CID,bus,num;
 
     CID = AsignaCID();
     
// Metemos en el vector de canales un nuevo elemento Canal que creamos con su constructor
 
//     canales.push_back(new L2capChannel(CID,PSM,s)); // Puntero a socket
     canales.push_back(new L2capChannel(CID,PSM,(void*)this,&Wrapper_a_escribeEnSocket)); // Callback
     
 
// Metemos tambien los datos del canal que hemos creado para registrarlo en la tabla
 
     Ttabla elementoTabla;
     elementoTabla.CID = CID;
     elementoTabla.PSM = PSM;
     tabla.push_back(elementoTabla);
     ImprimeTabla();        
 
    bus=BuscaTabla(CID);
    if (bus &#62;=0)
    {
       num=canales[bus]-&#62;connectChannel(); // Llamamos a connectChannel dentro de L2capChannel
    }
    return res;
}
 
 
void L2cap::escribeEnSocket(std::string cadena)
{
     cout&#60;&#60;&#34;Cadenita a mandar: &#34;&#60;&#60;cadena&#60;&#60;endl;
     s-&#62;SendBytes(cadena);
}
 
 
 
void L2cap::Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena)
{
     cout&#60;&#60;&#34;Welcome to WRAPPER&#34;&#60;&#60;endl;
       L2cap* mySelf = (L2cap*) pt2Object;
       mySelf-&#62;escribeEnSocket(cadena);
       
      //mySelf-&#62;sendRaw();  // Esto debería de funcionar, pero tampoco
}
 
 

-----------------------------| l2capChannel.h |--------------------

Código: Text

#include &#60;iostream&#62;
#include &#60;string&#62;
#include &#60;tipos.h&#62;
#include &#60;constantes.h&#62;
#include &#60;Socket.h&#62;
 
 
using namespace std;
 
class L2capChannel
{
 
 
 public:
        
         L2capChannel (int CID, int PSM,Socket* a);  // Constructor. Se encarga de la correcta inicializacion
         L2capChannel (int CID, int PSM,void* a, void(*pt2Func)(void*, std::string));
         ~L2capChannel ();
         unsigned int Obtener_estado();
 
         int entradaComandos (Tpdu_L2CAP pdu, unsigned int longitud);
         int connectChannel();
        
 private:         
                       // VARIABLES GLOBALES
 
    unsigned int _estado; // Indica el estado en el que nos encontramos
    unsigned int _leidos;
    unsigned int _MTU_negociada;
    unsigned int _MTU_sig; // de señalizacion
    unsigned int _identifier, _receivedIdentifier;
    int _localCID, _remoteCID, _PSM;
    void* _ME;
 
    Socket* sockCanal;
 
 
                      //Variables de cada tipo de comando
 
  TL2CAP_con_req L2CAPcon_req_TX, L2CAPcon_req_RX;
  TL2CAP_con_res L2CAPcon_res_TX, L2CAPcon_res_RX;
    
 
                         //     FUNCIONES
    
    void sendComando (unsigned int tipocomando);    
    void imprimeArray (Tpdu_L2CAP datain, unsigned int longitud);
 
    
                         // funciones de lectura de cada tipo de trama-C        
        void leerL2CAPcon_req(Tpdu_L2CAP pdu, unsigned int &n);
        int  leerL2CAPcon_res(Tpdu_L2CAP pdu, unsigned int &n);
 
        void imprimeComando (unsigned int codigo);
    
 
    void escribeL2CAPcon_req_TX (void);
    void escribeL2CAPcon_res_TX (int result);
 
    
    void situacion ();
        
    void vuelcaL2CAPcon_req(Tpdu_L2CAP &dataout);
    void vuelcaL2CAPcon_res(Tpdu_L2CAP &dataout);
    
    string arrayToString(Tpdu_L2CAP a);
    bool Esnumero (char valor);
};
 
 
 

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Domingo 2 de Diciembre de 2007, 14:12

-----------------------------| l2capChannel.cpp |--------------------

Código: Text

#include &#60;stdlib.h&#62;
#include &#60;iostream&#62;
#include &#60;time.h&#62;
#include &#60;sstream&#62;
#include &#60;string&#62;
#include &#60;L2capChannel.h&#62;
 
 
using namespace std;
 
 
 
L2capChannel::L2capChannel (int CID, int PSM, Socket* a)  // Constructor
{
    _estado = CLOSED;
    _localCID = CID;
    _PSM = PSM;
    sockCanal = a;
 
    std::string cad = &#34;080001000305040001004000&#34;; 
    sockCanal-&#62;SendBytes(cad); // No escribe, no se por que
}
 
L2capChannel::L2capChannel (int CID, int PSM,void* a, void(*pt2Func)(void*, std::string))
{
    _estado = CLOSED;
    _localCID = CID;
    _PSM = PSM;
    _ME = a; 
    cout&#60;&#60;&#34;Se supone que enviamos!&#34;&#60;&#60;endl;   
    pt2Func (_ME,&#34;080001000205040001004000&#34;); // Llama al Wrapper y éste deberia escribir, pero no lo hace
 
//    _ME-&#62;sendRaw(); // deberia poder mandar asi tambien, pero no
}
 
L2capChannel::~L2capChannel ()  // Constructor
{
}
 
 
 
void L2capChannel::imprimeArray (Tpdu_L2CAP datain, unsigned int longitud)
{
     unsigned int i;
 
   printf(&#34; &#092;n&#092;n El array de datos es el siguiente: &#092;n &#092;n&#34;);      
     for (i=0; i&#60;(longitud); i++)
     {
         printf(&#34;%X &#34;,*(datain+i));         
     }
   printf(&#34; &#092;n &#092;n&#34;); 
}
 
 
void L2capChannel::escribeL2CAPcon_req_TX ()
{
    L2CAPcon_req_TX.Code = L2CAP_CONREQ;
    L2CAPcon_req_TX.ID = _identifier;              
    L2CAPcon_req_TX.Length = 4;
    L2CAPcon_req_TX.PSM = _PSM;
    L2CAPcon_req_TX.SCID = _localCID;
}
 
 
void L2capChannel::escribeL2CAPcon_res_TX (int result)
{
       L2CAPcon_res_TX.Code = L2CAP_CONRES;
       L2CAPcon_res_TX.ID = L2CAPcon_req_RX.ID;    
       L2CAPcon_res_TX.Length = 6;
       L2CAPcon_res_TX.DCID = _localCID;
       L2CAPcon_res_TX.SCID = _remoteCID;
       L2CAPcon_res_TX.Result = result;
       L2CAPcon_res_TX.Status = 0x0000;
}
 
 
 
 
void L2capChannel::leerL2CAPcon_req(Tpdu_L2CAP datain, unsigned int &n)
{
    L2CAPcon_req_RX.Code = *(datain + n);
   L2CAPcon_req_RX.ID = *(datain + n+1);    
  L2CAPcon_req_RX.Length = *(datain + n+2) + (*(datain+n+3))*256;
  L2CAPcon_req_RX.PSM = *(datain + n+4) + (*(datain+n+5))*256;
  L2CAPcon_req_RX.SCID = *(datain + n+6) + (*(datain+n+7))*256;
  int _remoteCID = L2CAPcon_req_RX.SCID;
    
    n += (L2CAPcon_req_RX.Length + 4);
    cout&#60;&#60;&#34;vamos por aqui&#34;&#60;&#60;endl;
 
 
    if (_estado==CLOSED)
    {
       unsigned int result=0; //successfull
       if (result==0)
       {
          escribeL2CAPcon_res_TX (result);
          _estado=WAIT_CONFIG;
       }
       else if (result==1) //pending
       {
            escribeL2CAPcon_res_TX (result);
            _estado=WAIT_CONNECT;
       }
       else //No puede
       {
            escribeL2CAPcon_res_TX (result);
       }
       sendComando(L2CAP_CONRES);
    }
} // leerL2CAPcon_req
 
 
int L2capChannel::leerL2CAPcon_res(Tpdu_L2CAP datain, unsigned int &n) 
{
    unsigned int _receivedIdentifier = *(datain + n+1);
    
     switch (_estado)
     {
      case WAIT_CONNECT_RSP:
           {
                if (L2CAPcon_req_RX.ID !=_receivedIdentifier)
                {
                   cout&#60;&#60;&#34;Identificador no se corresponde con el esperado.&#34;&#60;&#60;endl;      
                   return 2;
                }
            
                L2CAPcon_res_RX.Code = *(datain + n);      // Code = 03
              L2CAPcon_res_RX.ID = *(datain + n+1);    
              L2CAPcon_res_RX.Length = *(datain + n+2) + (*(datain+n+3))*256;
              L2CAPcon_res_RX.DCID = *(datain + n+4) + (*(datain+n+5))*256;
              L2CAPcon_res_RX.SCID = *(datain + n+6) + (*(datain+n+7))*256;
              L2CAPcon_res_RX.Result = *(datain + n+8) + (*(datain+n+9))*256;
              L2CAPcon_res_RX.Status = *(datain + n+10) + (*(datain+n+11))*256;
            
                n += (L2CAPcon_res_RX.Length + 4);  
                        
               switch (L2CAPcon_res_RX.Result)
               {
                      case 0: //Success
                           {
                            _estado = WAIT_CONFIG;
                            _remoteCID = L2CAPcon_res_RX.DCID;
                            break;
                           }
                      case 1: //pending
                           {
                           break;
                           }
                      case 2: //Refused
                           {
                           _estado = CLOSED;
                           cout&#60;&#60;&#34;PSM not supported.&#34;&#60;&#60;endl;
                           return -1;
                           break;
                           }
                      case 3: //Refused
                           {
                           _estado = CLOSED;
                           cout&#60;&#60;&#34;Security block.&#34;&#60;&#60;endl;
                           return -1;
                           break;
                           }
                      case 4: //Refused
                           {
                           _estado = CLOSED;
                           cout&#60;&#60;&#34;No resources available.&#34;&#60;&#60;endl;
                           return -1;
                           break;
                           }
                           
                      default:
                              {
                              }                      
               }               
               return 0;
               break;
           }
 
      default :
              {
               return 1;
              }
     }
}
 
 
 
void L2capChannel::imprimeComando (unsigned int codigo)
{
     unsigned int i;
     
     switch (codigo)
     {
     case L2CAP_CONREQ :
      {
        printf(&#34;&#092;n &#092;n*****Connection Request******* &#092;n&#34;);                                   
        printf(&#34;El campo Code es de valor %X &#092;n&#34;,L2CAPcon_req_RX.Code);
        printf(&#34;El campo ID es de valor %X &#092;n&#34;,L2CAPcon_req_RX.ID);
        printf(&#34;El campo Length es de valor %X &#092;n&#34;,L2CAPcon_req_RX.Length);
        printf(&#34;El campo PSM es de valor %X &#092;n&#34;,L2CAPcon_req_RX.PSM);
        printf(&#34;El campo SCID es de valor %X &#092;n &#092;n&#34;,L2CAPcon_req_RX.SCID);
      break;
      }
     case L2CAP_CONRES :
      {
        printf(&#34;&#092;n &#092;n*****Connection Response******* &#092;n&#34;);                                   
        printf(&#34;El campo Code es de valor %X &#092;n&#34;,L2CAPcon_res_RX.Code);
        printf(&#34;El campo ID es de valor %X &#092;n&#34;,L2CAPcon_res_RX.ID);
        printf(&#34;El campo Length es de valor %X &#092;n&#34;,L2CAPcon_res_RX.Length);
        printf(&#34;El campo DCID es de valor %X &#092;n&#34;,L2CAPcon_res_RX.DCID);
        printf(&#34;El campo SCID es de valor %X &#092;n&#34;,L2CAPcon_res_RX.SCID);
        printf(&#34;El campo Result es de valor %X &#092;n&#34;,L2CAPcon_res_RX.Result);
        printf(&#34;El campo Status es de valor %X &#092;n &#092;n&#34;,L2CAPcon_res_RX.Status);
      break;
      }
     }
}
 
 
int L2capChannel::entradaComandos (Tpdu_L2CAP pdu, unsigned int longitud)
{
    int res;
    unsigned int n, tipocomando;
 
    // Comprobamos que realmente se ha recibido una trama de control
  if (!(*(pdu+2)==0x01)&(*(pdu+3)==0x00))   
  {
    cout&#60;&#60;&#34;Esperado trama-C. Entrada no valida.&#34;&#60;&#60;endl;
    return 1;
  }
    cout&#60;&#60;&#34;Efectivamente era una trama de control. Ya estamos en el CANAL.&#34;&#60;&#60;endl;
 
    
    n = 4; 
 
       _receivedIdentifier = *(pdu+5); // de momento, sin considerar varios comandos en 1 trama-C
 
       tipocomando = *(pdu+n);
       switch (tipocomando)
       {
              case L2CAP_CONREQ:
                   {
                    leerL2CAPcon_req(pdu,n);
                    break;
                   }
                   
              case L2CAP_CONRES:
                   {
                    res = leerL2CAPcon_res(pdu,n);
                    break;
                   }
              default :
                      {
                           cout &#60;&#60;&#34;Comando no valido.&#34;&#60;&#60;endl;
                           return 2;
                           break;
                      }
       }    
       situacion ();
   return 0;
}
 
 
void L2capChannel::situacion ()
// Saca por pantalla el estado en el que nos encontramos
{
   switch (_estado)
   {
   case CLOSED :
        {
               printf(&#34;&#092;t &#092;t Estado = CLOSED &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONNECT :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONNECT &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONNECT_RSP :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONNECT_RSP &#092;n &#092;n&#34;);
               break;
        }
   case OPEN :
        {
               printf(&#34;&#092;t &#092;t Estado = OPEN &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_DISCONNECT :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_DISCONNECT &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONFIG :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONFIG &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_SEND_CONFIG :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_SEND_CONFIG &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONFIG_REQ_RSP :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONFIG_REQ_RSP &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONFIG_RSP :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONFIG_RSP &#092;n &#092;n&#34;);
               break;
        }
   case WAIT_CONFIG_REQ :
        {
               printf(&#34;&#092;t &#092;t Estado = WAIT_CONFIG_REQ &#092;n &#092;n&#34;);
               break;
        }
   default :
           {
           }
   }
}
 
 
string L2capChannel::arrayToString(Tpdu_L2CAP a) 
{
    unsigned int longitud,num,cal;
 
    longitud = *(a) + (*(a+1))*256;
    
    string result = &#34;&#34;;
 
    for (int i=0; i&#60;longitud; i++) 
    {
      num = a[i];
        if (Esnumero(char((num/16)+'0')))
        {
          result = result + char((num/16)+'0'); 
        }
        else
        {
           result = result + char((num/16)+'A'-10);  
        }
        cal=(num-(num/16)*16);
        if (Esnumero(char( cal+'0')))
        {
          result = result + char(cal+'0'); 
        }
        else
        {
           result = result + char(cal+'A'-10);  
        }
    }
    return result;
}
 
 
bool L2capChannel::Esnumero (char valor)
{
     bool test;
     
     switch (valor)
     {
            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
            case '9':
            case '0':
                 {
                     test = true;
                     break;
                 }
            default :
                    {
                          test = false;
                          break;
                    }
     }
     return test;
}
 
 
 
void L2capChannel::sendComando (unsigned int tipocomando)
{
     string cad;
     Tpdu_L2CAP dataout ={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};  
 
     printf(&#34;&#092;n Se va a enviar a continuacion una PDU de contenido: &#092;n&#34;);
   switch (tipocomando)   
    {                             
    case L2CAP_CONREQ :    //0x02
          {
          vuelcaL2CAPcon_req(dataout);
          imprimeArray (dataout,L2CAPcon_req_TX.Length + 8);
          break;
           }
 
    case L2CAP_CONRES :    //0x03
          {
          vuelcaL2CAPcon_res(dataout);
          imprimeArray (dataout,L2CAPcon_res_TX.Length + 8);          
          break;
          }
    default : {
                    printf(&#34;Error. Campo Codigo incorrecto en SendComando &#092;n&#34;);
          }
    }
    
    cad = arrayToString(dataout);
        cout&#60;&#60;&#34;Se va a enviar por el socket una PDU de contenido: &#34;&#60;&#60;cad&#60;&#60;endl;
 
//        sockCanal-&#62;SendBytes(cad); // Canal manda mensaje por socket, si pasasemos el puntero a socket en el constructor
 
//    pt2Func (_ME,cad); // Llama al Wrapper y éste deberia escribir, pero no lo hace
          
} //SendComando
 
 
// ********FUNCIONES DE VOLCADO DE DATOS DESDE LAS VARIABLES REGISTRO********
//  ******************** AL ARRAY DE SALIDA (PDU)****************************
void L2capChannel::vuelcaL2CAPcon_req(Tpdu_L2CAP &dataout)
{
     unsigned int longitud,ind,res,coc;
     
     longitud = L2CAPcon_req_TX.Length;
     coc = longitud + 4;
     for (ind=0;(ind&#60;2);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     *(dataout+ind) = 0x1;     // trama de control
     ind++;
     *(dataout+ind) = 0x0;     
     ind++;;
          
     *(dataout+ind) = L2CAPcon_req_TX.Code;
     ind++;
 
     *(dataout+ind)= L2CAPcon_req_TX.ID;
     ind++;
 
 
     coc = L2CAPcon_req_TX.Length;
 
     for (ind=6;(ind&#60;8);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
     
     coc = L2CAPcon_req_TX.PSM;
 
     for (ind=8;(ind&#60;10);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     coc = L2CAPcon_req_TX.SCID;
 
     for (ind=10;(ind&#60;12);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
}
 
 
 
void L2capChannel::vuelcaL2CAPcon_res(Tpdu_L2CAP &dataout)
{
     unsigned int longitud,ind,res,coc;
     
     longitud = L2CAPcon_res_TX.Length;
     coc = longitud + 4;
 
     for (ind=0;(ind&#60;2);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     *(dataout+ind) = 0x1;     // trama de control
     ind++;
     *(dataout+ind) = 0x0;     
     ind++;;
     
     
     *(dataout+ind) = L2CAPcon_res_TX.Code;
     ind++;
 
     *(dataout+ind)= L2CAPcon_res_TX.ID;
     ind++;
 
 
     coc = L2CAPcon_res_TX.Length;
 
     for (ind=6;(ind&#60;8);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
 
     coc = L2CAPcon_res_TX.DCID;
 
     for (ind=8;(ind&#60;10);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     
     coc = L2CAPcon_res_TX.SCID;
 
     for (ind=10;(ind&#60;12);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     coc = L2CAPcon_res_TX.Result;
 
     for (ind=12;(ind&#60;14);ind++)
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
 
     coc = L2CAPcon_res_TX.Status;
 
     for (ind=14;(ind&#60;(longitud+8));ind++) 
     {
         res = coc % 256;
         *(dataout+ind) = res;
         coc = coc / 256;
     }
}
 
 
 
int L2capChannel::connectChannel()
{
 cout&#60;&#60;endl&#60;&#60;endl&#60;&#60;&#34;Creando CANAL&#34;&#60;&#60;endl&#60;&#60;endl;
    if (_estado == CLOSED)
    {
        srand(time(NULL));
        _identifier=rand();
 
        escribeL2CAPcon_req_TX ();
        sendComando (L2CAP_CONREQ);
 
        _estado = WAIT_CONNECT_RSP;
        return 0;
    }
    else
    {
        cout&#60;&#60;&#34;Apertura canal no valida. Estado no CLOSED.&#34;&#60;&#60;endl;
        return 1; 
    }
}
 
 

:ayuda:

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Domingo 2 de Diciembre de 2007, 14:22

Si todo eso compila cuando pueda le dare una ojeada ya que ahora no tengo nada de tiempo. Igual te recomiendo que lo depures, si decis que escribe la linea en la pantalla fijate que pasa con lo que se supone que deberia enviar por el socket. Comproba que haga el send ... y que valor devuelve claro.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Domingo 2 de Diciembre de 2007, 15:28

Muchas gracias EternalIdol.

Sigo intentando encontrar el por qué no funciona. Estaré atento a tu respuesta cuando puedas. Muchísimas gracias.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Lunes 3 de Diciembre de 2007, 16:43

No logro dar con el por qué :(

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Lunes 3 de Diciembre de 2007, 21:21

Cual es EXACTAMENTE la linea desde donde se deberia mandar y la linea desde la cual se deberia recibir ese dato.

PD. ¿Que es PC.? Lo cambie por localhost asi no me tiraba una excepcion ...

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Lunes 3 de Diciembre de 2007, 22:28

pc. es el nombre de mi computadora. En ese campo debe ir el nombre del host, de quien abre la conexión.

La línea que debería provocar la escritura es, justo en el Constructor del canal L2capchannel, la que dice:

pt2Func (_ME,"080001000205040001004000");

O sea, justo cuando creamos el canal para meterlo en el vector de canales, justo cuando lo creamos, en el costructor estamos mandando datos (esto lo hice así para probar cuanto antes el tema de los sockets).

Esa línea no es la escritura en sí, sino que provoca que se llame al Wrapper definido en L2cap (y efectivamente se le llama correctamente, ya que se muestra por pantalla un mensaje de que se está en el Wrapper).

Código: Text

void L2cap::Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena)
{
    cout&#60;&#60;&#34;Welcome to WRAPPER&#34;&#60;&#60;endl;
      L2cap* mySelf = (L2cap*) pt2Object;
      mySelf-&#62;escribeEnSocket(cadena);
      
     //mySelf-&#62;sendRaw();  // Esto debería de funcionar, pero tampoco
}
 

En escribeEnSocket es donde se realiza la escritura en sí, y se le pasa la cadena a escribir.

En ella se realiza un SendBytes, que es lo que envía por el socket.

Muchas gracias.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 4 de Diciembre de 2007, 23:18

Para el funcionamiento de los sockets tengo incluidas en el proyecto las bibliotecas de libwsock32.a y winsock2.h.

Son las únicas bibliotecas u objetos añadidos en las opciones de proyecto. Todo lo demás está en el código.

:unsure:

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Miércoles 5 de Diciembre de 2007, 18:41

Recien hoy tuve tiempo de ponerme con esto unos minutos, efectivamente la escritura se hace aca:

Código: Text

 
void Socket::SendBytes(const std::string& s)
{
 send(s_,s.c_str(),s.length(),0);
}

Y send devuelve el tamaño de la cadena enviada (el envio es correcto). s (la cadena) aparentemente es correcto, igual depuralo y comproba que s_ sea el socket que queres

No me dijiste donde se recibe.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 5 de Diciembre de 2007, 21:39

El socket es creado en la capa L2CAP que creamos cuando elegimos la opción cliente o servidor.

Cuando elegimos Servidor, hacemos un socketserver en el puerto 3000, y estamos ahi a la escucha, y además creamos un thread paralelo a la escucha siempre de lo que pueda venir por el socket.

Cuando elegimos Cliente se define un SocketClient por ese mismo puerto 3000, y se permanece a la escucha permanente en otro thread por si llegan datos por el puerto 3000.

Cuando el canal de la capa correspondiente a servidor realiza la llamada a Sendbytes y envía por el socket, el Cliente está a la escucha de llegada de datos por ese puerto 3000, y por tanto debería recibir la cadena enviada.

La recepción de los datos por el socket se realiza en bucleLectura, a la cual se le pasa un puntero y siempre llama a thisL2cap->leerSocket(), que es donde se realiza el ReceiveBytes().

El único socket que tengo definido es 's', en L2CAP. Ya que a los canales, les paso en el constructor un puntero a ese mismo socket s, y la variable sockCanal es simplemente una copia de dicho puntero.

Debería de funcionar, ¿no? :(

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 00:23

Cambie ese numero, que llega perfectamente, por una cadena:

Conexion Recibida
Sigo aqui en modo Servidor...

Esperando Nuevos datos...
Voy a leer
Recibida una string de longitud 26
y contenido: Evidentemente funciona ...

Es una trama B

Ya he leido

Esperando Nuevos datos...

No se cual es tu problema ya que esa funcion solo se usa en un lugar y va bien, depura tu codigo por favor.

Este codigo en (arg) primero devuelve l valor de la cadena y despues 0:
ioctlsocket(s_, FIONREAD, &arg)

Y fijate que se come el 100% del CPU ...

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 11:17

Eternal Idol, pues a mi no me realiza esas acciones al ejecutarlo.

He probado a cambiar la cadena como tu dices, pero no funciona. Ni la cadena numérica ni una cadena de letras se reciben.

En la ventana del Servidor solo se muestra lo siguiente:

Conexion Recibida
Sigo aqui en modo servidor

Esperando nuevos datos
Voy a leer
Sigo aqui en modo servidor
Sigo aqui en modo servidor
Sigo aqui en modo servidor
Sigo aqui en modo servidor
Sigo aqui en modo servidor

....

El servidor no recibe nada, y debería de hacerlo, ¿no?

Muchas gracias por las molestias. ¿Podría ser del compilador? No lo creo, ¿no? Uso el dev c++. Ya es que no se que puede estar pasando. Estoy revisando las líneas de código una por una, lo que debe de ejecutarse, y en principio debería ir. No se :(

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 11:24

Si dicho envío de información a través del socket lo realizamos directamente desde mi programa principal llamando a la función que escribe en el socket [situada en l2cap], dicho envío se realiza correctamente y los datos llegan a la otra entidad. Sin embargo, si quien provoca dicho envío es el canal [que intenta enviar mediante la callback], ésto no se realiza así, y debrían de obtenerse los mismos resultados.

Como bien has dicho, el funcionamiento debería de ser ese, que el Servidor mostrase: Conexion aceptada, leer datos, se ha recibido la cadena con contenido"...", y mas datos acerca de la cadena recibida.

Sin embargo lo que obtengo yo por pantalla no es eso, sino que el servidor está a la escucha del socket y no le llega nada. Se queda en Voy a leer, y no vuelve a sacar un mensaje por pantalla, por lo que no le llega ninguna cadena por el socket.

Y el envío debería realizarse inmediatamente al crear el canal, ya que en el constructor de dicho canal, he incluido que el canal envíe por el socket una cadena determinada, directamente desde el constructor. De manera que no hace falta que se realice ninguna operación sobre el canal desde L2CAP, sino que al crearlo, automáticamente debe de haber comunicación por el socket.

De hecho, el canal llama correctamente al Wrapper, con lo cual la callback está realizada de manera correcta (se muestra un mensaje por pantalla de que éste ha sido llamado), y se llama desde el Wrapper a la función que escribe en el socket. Pero los datos no llegan a la otra entidad, y deberían.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 11:25

Cita de: "captaindanieo"

El servidor no recibe nada, y debería de hacerlo, ¿no?

Muchas gracias por las molestias. ¿Podría ser del compilador? No lo creo, ¿no? Uso el dev c++. Ya es que no se que puede estar pasando. Estoy revisando las líneas de código una por una, lo que debe de ejecutarse, y en principio debería ir. No se :(

Si, la logica es que pudiera. Proba a cambiar eso de PC. por localhost como hice yo, no veo otra diferencia.

Yo estoy usando VC++ pero al final esto debe usar la API de Windows para los sockets con lo que no deberia haber ninguna diferencia en ese sentido.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 11:28

Cita de: "captaindanieo"

Si dicho envío de información a través del socket lo realizamos directamente desde mi programa principal llamando a la función que escribe en el socket [situada en l2cap], dicho envío se realiza correctamente y los datos llegan a la otra entidad. Sin embargo, si quien provoca dicho envío es el canal [que intenta enviar mediante la callback], ésto no se realiza así, y debrían de obtenerse los mismos resultados.

Te estas centrando demasiado en toda tu arquitectura - te aclaro que yo la estoy obviando -, DEPURA el codigo por favor. Comproba los valores devueltos por send y ioctlsocket.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 11:32

Ok Eternal Idol, voy a ello. Muchisimas gracias.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 13:06

He cambiado lo de pc. por localhost, aunque el resultado sigue siento el mismo.

He insertado unas lineas dentro de la clase SOCKET, que saquen por pantalla el valor de la variable _s, para ver su valor. Lo he realizado con un cout, y realizando una pausa justo tras escribirlo, ya que al estar siempre leyendo en el socket repetidamente no sbaa tiempoa ver si al principio de la ejecución el valor de s_ era diferente o no.

He probado a ejecutar el programa que en lugar de realizar desde el principal la llamada a OpenChannelReq, lo haga a SendRaw (que envía una cadena de caracteres directamente).

El resultado de dicha ejecución es exitoso, y hay una transferencia de información desde el cliente a el servidor.

Los valores de s_ en transmisión (sendbytes), y en recepción (receivebytes) son:

En el servidor RX = 164, y TX = 164. Siempre.

En el cliente, TX = 124, y RX la primera vez toma un valor de 124 y las siguientes toma el valor 4518412.

La verdad es que no se que valores deberían de estar tomando s_ para que la transferencia fuera exitosa. Pero en este caso, la transferencia de datos ocurre y se hace de manera correcta.

Sin embargo, cuando estamos llamando a OpenChannelReq desde el principal, en lugar de estar llamando a SendRaw no hay transferencia desde el cliente al servidor.

Los valores de s_ son:

Servidor RX = 164, TX no se llega a transmitir nada y no aparece su valor, pero supongo que será también de 164 al igual que en la ejecución anterior con SendRaw.
En el cliente TX = 64, y RX = 64 la primera vez, y 4518412 las sucesivas.

:(

¿Como lo habeis probado para que aparezca por el Servidor los datos enviados? ¿Solo cambiaste localhost y se está llamando a OpenChannelReq desde el principal?

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 13:17

Cita de: "captaindanieo"

¿Como lo habeis probado para que aparezca por el Servidor los datos enviados? ¿Solo cambiaste localhost y se está llamando a OpenChannelReq desde el principal?

Yo (solo, habeis es plural) lo probe exactamente con tu codigo. Los unicos cambios fueron el PC. por localhost y la cadena (aunque eso es innecesario, solo lo hice para asegurarme). Otra cosa, que tampoco afecta, que cambie fue los includes de tus archivos que estaban como <> por "", no deberian ser buscados en otras carpetas.

Proba justo esas dos maneras (la que te funciona y la que no) al mismo tiempo para ver si usan el mismo socket ... fijate que las dos lleguen hasta el send (la funcion de la API de Windows send) y que esta devuelva como valor de retorno el tamaño de la cadena.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 16:19

He modificado los includes con las "". Y he probado a ejecutar las dos maneras al mismo tiempo (es decir, 4 ventanas de ejecución de programa), pero cada uno parece ejecutarse de manera independiente.

He incluido que se imprima por pantalla el valor devuelto por send, y en el caso que funciona (ejecutando con SendRaw en principal), efectivamente send devuelve el valor de la longitud de la cadena que se va a enviar.

Sin embargo cuando hacemos la ejecución del programa haciendo OpenChannel, el valor devuelto es -1 en lugar de la longitud de la cadena que se supone que va a mandar.

He probado a compilar el código en otro ordenador, pero el resultado es el mismo.

Debe de ser un problema de los sockets, que no estén bien definidos o algo. Es que no puedo explicarmelo. :(

pd: quise hablarte de ti, en habeis. No se por qué puse eso en lugar de has.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 16:29

Cita de: "captaindanieo"

En el caso que funciona efectivamente send devuelve el valor de la longitud de la cadena que se va a enviar.

Sin embargo cuando hacemos la ejecución del programa haciendo OpenChannel, el valor devuelto es -1 en lugar de la longitud de la cadena que se supone que va a mandar.

OK, ya estamos con algo cercano al problema entonces (como decia hay que depurarlo ;)). En la documentacion (MSDN) dice que el valor de retorno cuando se produce un error es SOCKET_ERROR (-1) y que para obtener un valor mas especifico uses WSAGetLastError.

¿Estas usando el mismo socket las dos veces? ¿Si cambias el orden de estos dos intentos de envio el resultado sigue siendo el mismo?

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 17:04

He llamado a dicha función justo después de imprimir por pantalla el valor devuelto por send, y se devuelve un valor de 10038.

He buscado en la documentación, y se corresponde a éste error:

WSAENOTSOCK
10038

Socket operation on nonsocket.

An operation was attempted on something that is not a socket. Either the socket handle parameter did not reference a valid socket, or for select, a member of an fd_set was not valid.

Las ejecuciones que estoy realizando (una haciendo que el principal llame a SendRaw, y la otra que llame a OpenChannelreq), son totalmente independientes la una de la otra en los intentos que estoy realizando ahora.

Antes probé a ejecutarlas todas simultáneamente, pero solo aquella vez.

El valor devuelto por GetLastError en el caso de SendRaw es un 0, lo cual indica que todo está correcto. (como ya podiamos ver en la ejecución, ya que los datos llegaban al Servidor).

Cuando llamamos a OpenChannelReq, ésta en L2CAP realiza una serie de acciones, y crea un canal nuevo. Al crear dicho canal, en el constructor, se hace que se produzca una callback, llamando a la función Wrapper_a_escribeEnSocket, y ésta realiza un escribeEnSocket y ya se hace la escritura.

En ningún punto de mi programa vuelvo a definir un socket, por lo que creo que el socket sigue siendo el mismo que la vez anterior.

¿Puede que el error esté en la función Wrapper_a_escribeEnSocket, al estar haciendo la llamada de escribeEnSocket desde el puntero myself?

Nunca había hecho callbacks y estuve siguiendo las instrucciones de un tutorial, y el ejemplo mostrado lo hacía de esa forma.

Como no sea que al hacer ese puntero, entienda que el socket ya no es el que era ... No se puede que sea eso ¿no? Pero entonces, ¿como tendría que ser para que se refiriese al mismo socket de mi capa?

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 18:26

Esta claro el problema ahora, s no es correcto, voy a ver si puedo reproducirlo aunque lo dudo. Te repito que no te voy siguiendo en tu arquitectura, por eso no te respondo a muchas de las preguntas pero creo que te estar acercando al problema finalmente.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 18:28

Muchas gracias por tu ayuda Eternal Idol.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 18:47

De nada, a mi me sigue funcionando.

Depura (o usa alguna cadena para mostrar en pantalla) los puntos donde es crean, se cierran y se usan los sockets. De esta manera espero que puedas saber la razon por la cual no es un socket valido en ese caso (yo no puedo reproducirlo :( ).

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Jueves 6 de Diciembre de 2007, 19:36

Pff, pero teniendo los mismos códigos ¿por qué obtenemos diferentes resultados?
:(

He mostrado mensajes por pantalla en cada creación, envío y recepción. Pero no logro saber por qué.

Envíame si puedes los archivos o el proyecto que tienes en un rar, a captaindanieo@yahoo.es . Lo mismo hay algo que está diferente y no caemos en la cuenta. Pero el código debe de ser exactamente el mismo. No lo se...

Si funcionase dicho código me daría una alegría, pero si no lo hiciese, y funciona en tu ordenador y no en el mio ... ya no se que hacer. :(

Muchas gracias por tu ayuda de todas formas, Eternal Idol. Un saludo.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Jueves 6 de Diciembre de 2007, 20:59

Los unicos cambios que hice son los que te conte, diferencias pueden ser millones, desde la version al el service pack de Windows, que usas otro compilador, etc, etc.

Depura (o usa alguna cadena para mostrar en pantalla) los puntos donde es crean, se cierran y se usan los sockets. Es la unica forma de comprender el problema realmente.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Viernes 7 de Diciembre de 2007, 00:53

Estoy intentando probar el código en otro compilador. He bajado la versión gratuita del visual c++. Microsoft Visual Studio 2008 Version 9.0.21022.8 RTM

No logro compilar ya que aparecen un montón de errores, y me imagino que será debido a que no están incluidas algunas librerias en el proyecto.

Código: Text

1&#62;------ Build started: Project: ProyectoFC, Configuration: Debug Win32 ------
1&#62;Compiling...
1&#62;SOCKET.cpp
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(53) : error C2011: 'fd_set' : 'struct' type redefinition
1&#62;        C:&#092;Archivos de programa&#092;Microsoft SDKs&#092;Windows&#092;v6.0A&#092;include&#092;winsock.h(68) : see declaration of 'fd_set'
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(101) : error C2011: 'timeval' : 'struct' type redefinition
1&#62;        C:&#092;Archivos de programa&#092;Microsoft SDKs&#092;Windows&#092;v6.0A&#092;include&#092;winsock.h(111) : see declaration of 'timeval'
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(109) : warning C4005: 'timercmp' : macro redefinition
1&#62;        C:&#092;Archivos de programa&#092;Microsoft SDKs&#092;Windows&#092;v6.0A&#092;include&#092;winsock.h(124) : see previous definition of 'timercmp'
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(112) : error C2011: 'hostent' : 'struct' type redefinition
1&#62;        C:&#092;Archivos de programa&#092;Microsoft SDKs&#092;Windows&#092;v6.0A&#092;include&#092;winsock.h(167) : see declaration of 'hostent'
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(120) : error C2011: 'linger' : 'struct' type redefinition
1&#62;        C:&#092;Archivos de programa&#092;Microsoft SDKs&#092;Windows&#092;v6.0A&#092;include&#092;winsock.h(531) : see declaration of 'linger'
1&#62;C:&#092;Dev-Cpp&#092;include&#092;WinSock2.h(147) : error C2011: 'netent' : 'struct' type redefinition
.....
 

La cuestión es, como se pueden añadir dichas librerias. Por ejemplo, winsock2.h y libwsock32.a. Ambas las tenia importadas en las opciones de proyecto en dev c++, pero en vc++ en las opciones de proyecto y el resto de menus no encuentro nada de eso. Y he consultado la ayuda, pero no encuentro la forma.

¿Como se añaden dichos archivos al proyecto, en el visual c++?

En fin, a ver si fuera cosa del compilador.

Un saludo.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Viernes 7 de Diciembre de 2007, 08:13

Lo contrario en este caso, tenes winsock.h y winsock2.h, deja solo la ultima. Por supuesto en el codigo que tengo yo esta #include <winsock2.h>, en cuanto al la biblioteca de importacion yo estoy usando ws2_32.lib y la tenes que agregar en las propiedades del proyecto, algo asi como enlazador, librerias adicionales. (Yo lo compile desde linea de comandos con el VC++ 8 - VS 2005 -).

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Viernes 7 de Diciembre de 2007, 12:30

No hay manera, se resiste la compilación con el vc++.

He creado otro nuevo proyecto desde cero. Un proyecto vacío. Y he añadido al proyecto los archivos de mi código.
He sustituido los <> en los includes por "". Y en uno de los archivos de socket, había un include que ponía un path entero para incluir el winsock2.h. Lo he quitado también.

En Project, en Properties, me voy a Configuration Properties, a Linker y a General. Y ahi una de las líneas que aparece es "Additional Library Directories". Ahi puedo indicarle el directorio donde se encuentran tanto winsock2 como ws2_32.lib, pero no estoy seguro de que las esté teniendo en cuenta, porque no le estoy indicando el archivo en sí.

No hay ningún otro sitio en el que pueda añadir librerias y archivos. En el devC++, en las opciones del proyecto, había un apartado que era Parámetros, Linker, y añadir libreria u objeto.

Pero aqui nada de nada.

La lista de errores que obtengo al compilar es:

Código: Text

[SIZE=1]1&#62;------ Build started: Project: ProyectoVC, Configuration: Debug Win32 ------
1&#62;Linking...
1&#62;L2cap.obj : error LNK2001: unresolved external symbol __RTC_Shutdown
1&#62;L2capChannel.obj : error LNK2001: unresolved external symbol __RTC_Shutdown
1&#62;principal.obj : error LNK2001: unresolved external symbol __RTC_Shutdown
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __RTC_Shutdown referenced in function &#34;private: static void __cdecl Socket::Start(void)&#34; (?Start@Socket@@CAXXZ)
1&#62;L2cap.obj : error LNK2001: unresolved external symbol __RTC_InitBase
1&#62;L2capChannel.obj : error LNK2019: unresolved external symbol __RTC_InitBase referenced in function &#34;public: __thiscall L2capChannel::L2capChannel(int,int,class Socket *)&#34; (??0L2capChannel@@QAE@HHPAVSocket@@@Z)
1&#62;principal.obj : error LNK2001: unresolved external symbol __RTC_InitBase
1&#62;SOCKET.obj : error LNK2001: unresolved external symbol __RTC_InitBase
1&#62;L2cap.obj : error LNK2019: unresolved external symbol __RTC_CheckEsp referenced in function &#34;unsigned int __stdcall bucleLectura(void *)&#34; (?bucleLectura@@YGIPAX@Z)
1&#62;L2capChannel.obj : error LNK2001: unresolved external symbol __RTC_CheckEsp
1&#62;principal.obj : error LNK2001: unresolved external symbol __RTC_CheckEsp
1&#62;SOCKET.obj : error LNK2001: unresolved external symbol __RTC_CheckEsp
1&#62;L2cap.obj : error LNK2019: unresolved external symbol &#34;__declspec(dllimport) public: __thiscall std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;(char const *)&#34; (__imp_??0?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@QAE@PBD@Z) referenced in function &#34;public: __thiscall L2cap::L2cap(int)&#34; (??0L2cap@@QAE@H@Z)
1&#62;L2capChannel.obj : error LNK2001: unresolved external symbol &#34;__declspec(dllimport) public: __thiscall std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;(char const *)&#34; (__imp_??0?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@QAE@PBD@Z)
1&#62;SOCKET.obj : error LNK2001: unresolved external symbol &#34;__declspec(dllimport) public: __thiscall std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;(char const *)&#34; (__imp_??0?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@QAE@PBD@Z)
.........
 
1&#62;ProyectoVC - 83 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========[/SIZE]
 
 

Edito. Acabo de encontrar otro menu, en herramientas, opciones, projects and solutions, vc++ directories. Y ahi se pueden especificar directorios para librery files, include files, ...

He añadido en library files el directorio donde se encuentra ws_32.lib y en include files el de winsock.h

Y los errores se reducen bastante aunque sigue habiendo:

Código: Text

[SIZE=1]1&#62;------ Build started: Project: ProyectoVC, Configuration: Debug Win32 ------
1&#62;Linking...
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__WSAStartup@8 referenced in function &#34;private: static void __cdecl Socket::Start(void)&#34; (?Start@Socket@@CAXXZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__WSACleanup@0 referenced in function &#34;private: static void __cdecl Socket::End(void)&#34; (?End@Socket@@CAXXZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__socket@12 referenced in function &#34;protected: __thiscall Socket::Socket(void)&#34; (??0Socket@@IAE@XZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__closesocket@4 referenced in function &#34;public: void __thiscall Socket::Close(void)&#34; (?Close@Socket@@QAEXXZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__recv@16 referenced in function &#34;public: class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62; __thiscall Socket::ReceiveBytes(void)&#34; (?ReceiveBytes@Socket@@QAE?AV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@XZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__ioctlsocket@12 referenced in function &#34;public: class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62; __thiscall Socket::ReceiveBytes(void)&#34; (?ReceiveBytes@Socket@@QAE?AV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@XZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__send@16 referenced in function &#34;public: void __thiscall Socket::SendLine(class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62;)&#34; (?SendLine@Socket@@QAEXV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__WSAGetLastError@0 referenced in function &#34;public: void __thiscall Socket::SendBytes(class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62; const &)&#34; (?SendBytes@Socket@@QAEXABV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__listen@8 referenced in function &#34;public: __thiscall SocketServer::SocketServer(int,int,enum TypeSocket)&#34; (??0SocketServer@@QAE@HHW4TypeSocket@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__bind@12 referenced in function &#34;public: __thiscall SocketServer::SocketServer(int,int,enum TypeSocket)&#34; (??0SocketServer@@QAE@HHW4TypeSocket@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__htons@4 referenced in function &#34;public: __thiscall SocketServer::SocketServer(int,int,enum TypeSocket)&#34; (??0SocketServer@@QAE@HHW4TypeSocket@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__accept@12 referenced in function &#34;public: class Socket * __thiscall SocketServer::Accept(void)&#34; (?Accept@SocketServer@@QAEPAVSocket@@XZ)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__connect@12 referenced in function &#34;public: __thiscall SocketClient::SocketClient(class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62; const &,int)&#34; (??0SocketClient@@QAE@ABV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@H@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__gethostbyname@4 referenced in function &#34;public: __thiscall SocketClient::SocketClient(class std::basic_string&#60;char,struct std::char_traits&#60;char&#62;,class std::allocator&#60;char&#62; &#62; const &,int)&#34; (??0SocketClient@@QAE@ABV?&#036;basic_string@DU?&#036;char_traits@D@std@@V?&#036;allocator@D@2@@std@@H@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol __imp__select@20 referenced in function &#34;public: __thiscall SocketSelect::SocketSelect(class Socket const * const,class Socket const * const,enum TypeSocket)&#34; (??0SocketSelect@@QAE@QBVSocket@@0W4TypeSocket@@@Z)
1&#62;SOCKET.obj : error LNK2019: unresolved external symbol ___WSAFDIsSet@8 referenced in function &#34;public: bool __thiscall SocketSelect::Readable(class Socket const * const)&#34; (?Readable@SocketSelect@@QAE_NQBVSocket@@@Z)
1&#62;C:&#092;Documents and Settings&#092;Dani&#092;Mis documentos&#092;Visual Studio 2008&#092;Projects&#092;ProyectoVC&#092;Debug&#092;ProyectoVC.exe : fatal error LNK1120: 16 unresolved externals
1&#62;Build log was saved at &#34;file://c:&#092;Documents and Settings&#092;Dani&#092;Mis documentos&#092;Visual Studio 2008&#092;Projects&#092;ProyectoVC&#092;ProyectoVC&#092;Debug&#092;BuildLog.htm&#34;
1&#62;ProyectoVC - 17 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========[/SIZE]
 
 

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Viernes 7 de Diciembre de 2007, 13:08

Tenes que usar winsock2.h:
#include <winsock2.h> en lugar del path del Dev-Cpp.

Para que enlace tenes que ir al proyecto, click derecho en Propertiesy:

Configuration Properties>>Linker>>Input>>Additional Dependencies y agregar ws2_32.lib nada mas.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Viernes 7 de Diciembre de 2007, 13:25

Compilación lograda.

Pero el resultado es el mismo. Se devuelve un -1 en getError.

E incluso diria que el resultado es peor que con dev C++, ya que cuando intento hacer una ejecución eligiendo SendRaw en el principal, también devuelve un -1. No se transmite por el socket en ninguno de los dos casos. Mientras que en devC++ sí se transmitia en éste último caso.

Edito: el error en concreto es el mismo que anteriormente, el 10038.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Viernes 7 de Diciembre de 2007, 13:30

-1 no es nada mas que un error generico, fijate cual es el error concreto (WSAGetLastError).

Si es el mismo error que antes:
Depura (o usa alguna cadena para mostrar en pantalla) los puntos donde es crean, se cierran y se usan los sockets. Es la unica forma de comprender el problema realmente.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Lunes 10 de Diciembre de 2007, 22:18

Creo que he encontrado el error.

En la función Wrapper_a_EscribeEnSocket, estaba llamando a Escribe en Socket, que realizaba un SendBytes, pero en realidad no estaba realizado correctamente.

El código de dicha función, a la que llamaba el canal mediante la callback, era:

Código: Text

void L2cap::Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena)
{
    cout&#60;&#60;&#34;Welcome to WRAPPER&#34;&#60;&#60;endl;
      L2cap* mySelf = (L2cap*) pt2Object;
      mySelf-&#62;escribeEnSocket(cadena);
}
 

Lo que ocurre es que mySelf no es mi capa L2CAP. mySelf es un objeto L2CAP, y por tanto tiene los mismos métodos y por eso no da error de compilación. Pero en realidad, ni he definido el comportamiento de dicha clase L2CAP que he creado (debería decirle si es Server o Client, en su constructor), ni es lo que esperaba realizar.

Yo lo que debería es hacer referencia a mi misma clase L2CAP ya creada. Esto me imagino que será usando el puntero this, aunque no tengo ni idea de como hacerlo. ¿Como sería? La idea del código está todo correcto, salvo el tema de que no estoy llamando a EscribeEnSocket de mi clase ya creada (y por tanto, el socket definido ya conocido), sino que estaba llamando a una clase L2CAP, y estaría usando otro socket seguramente.

El canal, se creaba de la siguiente manera:

Código: Text

int L2cap::Openchannel_req ()
{
...
 
    canales.push_back(new L2capChannel(CID,PSM,(void*)this,&Wrapper_a_escribeEnSocket)); // Callback
    
....
 
}

Y el canal, llamaba al wrapper desde el constructor del canal:

Código: Text

L2capChannel::L2capChannel (int CID, int PSM,void* a, void(*pt2Func)(void*, std::string))
{
   _estado = CLOSED;
   _localCID = CID;
   _PSM = PSM;
   _ME = a; 
   cout&#60;&#60;&#34;Se supone que enviamos!&#34;&#60;&#60;endl;   
   pt2Func (_ME,&#34;080001000205040001004000&#34;); // Llama al Wrapper
}
 

A ver si me pudieseis ayudar con esto, ya por lo menos está localizado el error. Esta mas cerca de solucionarse :)

Muchísimas gracias por todo!

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Lunes 10 de Diciembre de 2007, 22:45

No se realmente donde encontraste el error. Yo lo depuro y esta correcto:

En main tenes un objeto llamado micapa de la clase L2cap cuya direccion en memoria es en mi caso 0x0012feec. Sigo la pila y llegamos a Openchannel_req donde se crea un objeto de tipo L2capChannel. En el constructor del mismo se recibe como tercer parametro un void * a cuyo valor en este caso tambien es 0x0012feec. Ese constructor llama a Wrapper_a_escribeEnSocket con un parametro void *pt2Object con el mismo valor de siempre, ahi mismo tenes un puntero a un objeto de la clase L2cap mediante un casting a la direccion de siempre. Con lo cual mySelf es lo mismo que &micapa del main. Eso llama a escribeEnSocket donde this ya es igual a &micapa/mySelf y SendBytes lo mismo. Por eso mismo me funciona perfectamente.

mySelf es un puntero a micapa y no necesitas cambiar ni asignar ningun valor en el, el socket es el mismo.

Depura (o usa alguna cadena para mostrar en pantalla) los puntos donde se crean, se cierran y se usan los sockets. Es la unica forma de comprender el problema realmente.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Lunes 10 de Diciembre de 2007, 23:28

Es cierto. No se por que vi que ahí podría haber un error :(

Voy a ejecutar sacando información por pantalla de dichos momentos.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Lunes 10 de Diciembre de 2007, 23:48

He puesto salidas por pantallas en los momentos que se crean los sockets, en el constructor de L2CAP.

Cuando hago un socketServer, da un numero hexadecimal.
Cuando hago SocketClient, s toma otro valor hexadecimal.

Y saco por pantalla también el contenido de s en escribeEnSocket, y dicho valor es el mismo que el que cuando hacía SocketClient, lo cual es correcto. Ese lugar es el único en el que se realiza un envío por el socket.(SendBytes).

Si saco por pantalla el valor de s en el bucle de leer socket, en ambos casos se imprime su valor correspondiente (en cliente el del cliente, y en servidor el del servidor).

¿todo esta correcto no?

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Lunes 10 de Diciembre de 2007, 23:52

Es probable, a mi me funciona, pero no se si comprobaste los puntos donde esos sockets se cierran. Si te dice que el socket no es valido es por una razon ... o es un numero totalmente al azar o ese socket fue cerrado con anterioridad.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 00:25

Bueno, ese es el contenido de la variable s, en el programa.

Si lo que saco por pantalla es, en socket.cpp, el valor de s_ (que es el socket, ¿no?), los valores obtenidos son diferentes.

Código: Text

void Socket::SendBytes(const std::string& s)
{
send(s_,s.c_str(),s.length(),0);
}
 

Saca por pantalla que el valor de s_ es 64. (y 64, si lo pasamos a hexadecimal, es 40).

Si yo cojo, y en SendBytes modifico el valor de s_ al principio antes de hacer send, y le pongo el valor que debería de tener (es decir, el que mostraba por pantalla cuando era cliente), al ejecutar las cosas no son como deberían.

Le digo que: s_ = 0x22fe60; justo antes de hacer send.

Y lo mostrado por pantalla es, que el valor de s_ es igual a 2293344 ( que es 22fe60 en decimal) por lo tanto está correcto esto. Aunque al Servidor sicge sin llegarle nada.

Si le digo que el valor de s_ sea s_ = 0x3d27e0; (que es el valor cuando es Servidor) tampoco ocurre nada.

Lo que es un poco mosqueante, es que, en la Tabla de registro de canales L2CAP, que se imprime en la ventana del Cliente, imprime los valores de los campos CID y PSM de la posición 0 del vector. Y dichos valores son los correctos (concretamente el CID es 40, lo cual es correcto puesto que es el primer valor que debe asignar).

Sin embargo, cuando he hecho los cambios de asignarle a s_ un nuevo valor distinto del que tenía para ver si envíaba algo, pue spor pantalla salía el valor modificado de s_, pero también se modificaba el valor de CID de la tabla!

Y no se por que porque aparentemente no tienen ninguna relación. Ambas están en partes distintas del código. s_ se supone que es el socket, y CID es una variable que se supone que se asigna, independientemente de eso.

¿He encontrado algo útil?

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Martes 11 de Diciembre de 2007, 00:30

Si estas probando algo con el servidor por ahora olvidalo por completo, ejecutalo y no lo pruebes/depures, no tiene sentido. No se si encontraste algo ya que no se realmente que fue lo que hiciste. ¿Ya comprobaste los puntos donde se cierra el socket? No quiero repetir lo mismo 500 veces.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 00:43

Eternal Idol, siento de verdad mi torpeza en este problema. He intentado sacar toda la información que he podido obtener por pantalla.

No se con certeza el punto donde se cierran los sockets. La creación imagino que la he identificado correctamente, cuando definimos el socket en SocketClient y SocketServer. Pero el cierre, ... he buscado en la clase socket "close", y hay un closesocket(s_). He puesto que sacase una linea por pantalla informando del valor de s_ en el caso de que lo fuese a cerrar, pero no se ha imprimido por pantalla ningún valor, por lo tanto el socket no se ha cerrado.

Pido disculpas por no haber comprobado esto antes.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 00:46

Lo que hice antes fue, en el código de SendBytes en Socket.cpp, cambié el valor de s_ a un valor que le dí yo. Por pantalla mostraba dicho cambio, pero el cambio también afectaba al contenido del campo CID almacenado en la posición 0 del vector de la tabla de canales.

Eso es lo que explicaba en el post anterior.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Martes 11 de Diciembre de 2007, 00:47

Bien, no se cierra. Se crea con la funcion socket(), buscala y comproba que su valor de retorno (se supone que se crea uno solo) sea exactamente el mismo que pasas a send() siempre (s_).

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 00:59

En la búsqueda de "close" no había encontrado otros sitios donde se cerraba también el socket, al no ponerle que la búsqueda la realizara en totalidad del fichero, y no desde el cursor.

He puesto mensajes en todos los close, y he obtenido que en servidor, se crea el socket con s = 3d27e0 [s es la variable de l2cap], saca el mensaje de conexión recibida, t a continuación se produce un cierre de socket. Y el valor de s_ es DC (en hexa, que en decimal es 220).

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 01:13

He puesto a sacar por pantalla también el valor de s_ en Socket(), y comprobado con el valor de s_ en Send(), y no son iguales.

En el cliente, lo primero que se realiza es Socket(), y el valor devuelto es D4.
A continuación, en cuanto saca por pantalla el mensaje de Conexión Recibida, saca un mensaje por pantalla de que se ha cerrado el socket, y el valor de s_ es DC.

Y luego se queda ahi, esperando nuevos datos, ...

En el cliente pos su parte, al principio lo que se hace también primero es Socket(), y el valor de s_ es D4. Y en el Send() el valor de s_ es 64. Y entonces a continuación saca por pantalla la información de error (-1) y el codigo (10038).

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Martes 11 de Diciembre de 2007, 09:23

Siempre hace las comprobaciones en el ambito de cada proceso (cliente y servidor) no sirve de nada comparar entre ambos ya que al ser otro proceso su tabla de handles es completamente independiente.

En el cliente si socket() y send() usan un diferente s_ es logico que falle, comproba todos los puntos donde se podria cambiar este valor. Lo mejor es que lo depures, desde el momento en que s_ es asignado por socket() - donde tiene que ser valido - hasta el momento en que cambia. En el servidor se usa un socket para escuchar y despues hay otro para conexion aceptada y con ese se comunica.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 15:16

Esta noche cuando regrese me pondré a intentar localizar el punto donde se cambia el valor de s_ en el Cliente.

De todas formas, se produce un cierre de socket en el servidor, tras mostrar la aceptación de la conexión (Conexión recibida). No se tendría por qué producir un cierre de socket, ¿no?

Para aislar el que esté teniendo problemas en el servidor o en el cliente, puedo probar a crear un programa a parte, que no tenga nada que ver con mi código, y que lo que haga sea por ejemplo escuchar por el mismo puerto 3000, y sacar por pantalla lo que reciba.

Y otro que lo que haga sea escribir algo por ese puerto, y así testearía el comportamiento del servidor l2cap. ¿no?

Debería funcionar y haber comunicación. Tan solo declarar SocketClient, y hacer un SendBytes, o declarar SocketServer, hacer un accept y un receivebytes.

Un saludo y en cuanto tenga resultados los comento. Muchísimas gracias de nuevo.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Martes 11 de Diciembre de 2007, 23:29

Me dispongo a depurar el modo Servidor.

Elijo la opción servidor.
Se realizan una serie de acciones en allocator.h new_allocator.h y stl_vector.h, realizando reservas de memoria para el vector.

Después de esto, llegamos al constructor de L2CAP, y realiza las acciones de acuerdo con el modo elegido (servidor). Se realiza un SocketServer, al puerto 3000. sockaddr_in
Pasamos a Socket(), en la clase Socket.

Se llama a Start(). nofSockets y WSAStartup dice que no las encuentra en este contexto, con lo cual parece que no hace nada, y solo incrementa nofSockets, que indica lo mismo, que no la encuentra en el contexto. (Con lo cual aqui no se hace nada).

Seguimos en Socket(), y this->s_ (que es s_ en la clase socket) pasa a tomar el valor 1828.
refCounter_ vale 0x3d24d8. Salimos de Socket(), y seguimos en SocketServer, en memset.

sa.sin_family = 2
sa.sin_port = 47115

s_ = 1828

No detecta que sea un socket inválido, y tampoco entra en los bucles de que sea un NonBlockingSocket ni que se cumpla la condición de bind.... Seguimos por listen (s_,connections). [connections vale 5].

De ahi pasamos a Socket* sa=in.Accept(), que provoca irnos a Accept en Socket, y se queda ahi parado, esperando, en new_sock = accept (s_,0,0).

Paso ahora a ejecutar mi otro programa y a elegir modo cliente.

En ese momento, se produce un salto, y nos encontramos en la función Accept en SocketServer. Se llama a Start(). refcounter vale ahora 0xbaadf00d. Se devuelve el valor de r desde Accept en SocketServer, que es 0x3d2908.

Volvemos al constructor de L2CAP, y copiamos el valor de sa a s. Dicho valor es 0x22ff20. Imprime por pantalla el mensaje Conexion Recibida. Se coloca sobre _beginthreadex, y al darle a siguiente paso hace de nuevo SocketServer in (3000,5) ahi en el constructor de L2CAP. Se salta al destructor del socket. Se llama a Close, y éste hace closesocket(s_), y s_ vale 1828.

Se hace un delete refCounter en el destructor de Socket. El valor de refCounter es 0x3d24d8.

Volvemos a SocketServer in en el constructor de L2CAP, y se hace un salto al final del constructor y se sale de el. Quedando ya para siempre en el bucle del programa principal de mostrar por pantalla: "Sigo aqui en modo Servidor".

Desde luego que las acciones que hace ahi en el constructor de L2CAP no tienen ningún sentido, al menos no se lo veo. No se porque se destruye el socket, ni porqué se pasa a hacer de nuevo SocketServer. :(

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Martes 11 de Diciembre de 2007, 23:56

Tanto sentido como _escuchando = true; en la primera linea del constructor de L2cap pero es TU codigo. Todo ese constructor es erroneo ...

No se donde habras sacada esto:

Código: Text

 
  *(s) = sb; //Con esto hemos anclado el contenido del puntero y ya no se borra al salir del Constructor
 

En cuanto termina ese constructor se llama al destructor de in o sb segun corresponda ...

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 12 de Diciembre de 2007, 00:27

Esa línea la coloqué porque no sabía si el socket estaba siendo destruido en cuanto salía del constructor (cosa que efectivamente estaba pasando). Intenté remediarlo con esto, pero no vale para nada.

En cuanto al valor de la variable global escuchando la tengo inicializada ahí porque es una variable que necesito que desde la creación de mi nuevo objeto esté a true, para efectuar la lectura, y en el caso de que por el socket alguna vez reciba la cadena "exit", esa variable se pondrá a false, y se saldrá del bucle en el que se lee el socket contínuamente.

Lo que no entiendo es como el programa provoca unos resultados exitosos en tu ordenador, pero yo no logro hacerlo, y el comportamiento es totalmente erroneo. :(

Voy a intentar hacer dos constructores distintos, uno para el cliente y otro para el servidor. En lugar de hacer en el mismo constructor la distinción de si se le está pasando un 1 o un 2 para definir el comportamiento, aunque esto no deberñia de ser un problema, es un simple if, de una variable que se le pasa al constructor, ¿no?

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 12 de Diciembre de 2007, 00:55

Al eliminar la línea siguiente

*(s) = sb; //Con esto hemos anclado el contenido del puntero y ya no se borra al salir del Constructor

el error devuelto por getlasterror cambia, y ya no es 10038, sino 10093. He encontrado lo siguiente acerca de este error:

10093 WSANOTINITIALISED

"Successful WSAStartup not yet performed. Either the application has not called WSAStartup or WSAStartup failed. The application may be accessing a socket that the current active task does not own (that is, trying to share a socket between tasks), or WSACleanup has been called too many times."

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Miércoles 12 de Diciembre de 2007, 18:52

Tenes que arreglar ese constructor ... usa new para los objetos y no te olvides del delete correspondiente.

La diferencia es que se llama al operator = de la clase Socket y eso entre otras cosas aumenta la variable de las referencias (cuando no lo haces al ejecutarse el destructor y quedar sin referencias tambien se ejecuta End que llama a WSACleanup).

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 12 de Diciembre de 2007, 22:16

He cambiado las definiciones de los objetos L2cap desde principal. Ahora lo realizo:

L2cap* micapa = new L2cap(1);

Por ejemplo. Y para referirme ahora a los métodos de mi clase, usaré -> en lugar de '.' solo.

Sin embargo el resultado de la ejecución sigue siendo el mismo.

No he entendido bien la última parte de tu último post, Eternal Idol.

Otra cosa que queria comentar es la siguiente. Ejecutando paso por paso, en depuración, observo que el comportamiento, tanto en el servidor como en el cliente es similar en cuanto a lo siguiente: en el constructor, se realizan todas las acciones correspondientes, pero cuando se llega a beginthreadex, da un salto a SocketServer (la primera línea del constructor de la clase) y de ahí pasa a la destrucción del objeto de la clase.

Eso ocurre tanto si elegimos que sea Cliente como si es Servidor. Y ocurre tanto con la definición realizada con new, como con la que tenía antes.

¿Es normal esto?
Ademas, si pongo entre comentarios la línea del beginthreadex (para comprobar si era debido a dicha instrucción), ocurre exactamente lo mismo, solo que el salto se realiza desde la línea anterior. Y si comento la anterior, se realiza desde la anterior (que es un simple cout ), ... No tiene ningún sentido.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Miércoles 12 de Diciembre de 2007, 22:22

Tiene todo el sentido del mundo, lo que se llama es el destructor de los objetos locales que estan en la pila, en cuanto se acaba el constructor su ambito desaparece y por tanto se llama al destructor correspondiente (SocketServer/SocketClient). Lo que tenes que cambiar es el constructor mismo (L2cap::L2cap) como te dije antes.

La ultima parte de mi mensaje anterior explicaba la diferencia en los errores con y sin esa linea bizarra.

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 12 de Diciembre de 2007, 23:07

¡Creo que lo logramos! He realizado también las creaciones de los objetos en el constructor de L2CAP para el socket, de la siguiente manera:

En el servidor:

SocketServer* in = new SocketServer(3000,5);
Socket* sa = in->Accept();
s = sa;

En el cliente:

SocketClient* sb = new SocketClient("localhost",3000);
s = sb;

Y al hacer esto, ya hay transferencia correcta de información, y no se cierran los sockets. No me lo creia cuando lo veía.

Un millón de gracias Eternal Idol. De verdad, que no creía que lo pudiesemos solucionar, y mas pensando en que en tu máquina funcionaba el mismo código que en la mía no lo hacía. ¿Eso a qué podría haberse debido? Porque los constructores estaban igual de mal declarados antes. ¿Quizás por la forma de hacer las cosas del compilador?

En fin, muchísimas gracias de nuevo por todo, por haberte puesto con el código y haber tenido paciencia para soportar mis dudas y mis no comprobaciones. Mil gracias.

Un saludo muy grande desde Málaga.

Título: Re: Comunicación Por Sockets
Publicado por: Eternal Idol en Miércoles 12 de Diciembre de 2007, 23:36

De nadas, ahora revisa todo tu codigo teniendo en cuenta el ambito de las variables ;)

Título: Re: Comunicación Por Sockets
Publicado por: captaindanieo en Miércoles 12 de Diciembre de 2007, 23:37

Recibido! :D :comp:

SoloCodigo

Programación General => C/C++ => Mensaje iniciado por: captaindanieo en Domingo 2 de Diciembre de 2007, 14:08