Autor Tema: Re: Comunicación Por Sockets (Leído 11445 veces)

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

captaindanieo

-----------------------------| 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; 
    }
}
 
 

Eternal Idol

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.

captaindanieo

Muchas gracias EternalIdol.

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

captaindanieo

No logro dar con el por qué

Eternal Idol

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

captaindanieo

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.

captaindanieo

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.

Eternal Idol

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.

captaindanieo

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?

Eternal Idol

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

captaindanieo

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

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.

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.

Eternal Idol

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.

Eternal Idol

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.

captaindanieo

Ok Eternal Idol, voy a ello. Muchisimas gracias.

captaindanieo

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?

Eternal Idol

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.

captaindanieo

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.

Eternal Idol

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?

captaindanieo

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?

Eternal Idol

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.

captaindanieo

Muchas gracias por tu ayuda Eternal Idol.

Eternal Idol

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

).

captaindanieo

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.