• Viernes 8 de Noviembre de 2024, 23:16

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Temas - captaindanieo

Páginas: [1]
1
C/C++ / Re: Comunicación Por Sockets
« 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
  1. #ifndef SOCKET_H
  2. #define SOCKET_H
  3.  
  4. #include <C:\Dev-Cpp\include\WinSock2.h>
  5. #include <string>
  6.  
  7. enum TypeSocket {BlockingSocket, NonBlockingSocket};
  8.  
  9. class Socket {
  10.     public:
  11.     
  12.       virtual ~Socket();
  13.       Socket(const Socket&);
  14.       Socket& operator=(Socket&);
  15.     
  16.       std::string ReceiveLine();
  17.       std::string ReceiveBytes();
  18.     
  19.       void   Close();
  20.     
  21.       // The parameter of SendLine is not a const reference
  22.       // because SendLine modifes the std::string passed.
  23.       void   SendLine (std::string);
  24.     
  25.       // The parameter of SendBytes is a const reference
  26.       // because SendBytes does not modify the std::string passed
  27.       // (in contrast to SendLine).
  28.       void   SendBytes(const std::string&);
  29.     
  30.     protected:
  31.       friend class SocketServer;
  32.       friend class SocketSelect;
  33.     
  34.       Socket(SOCKET s);
  35.       Socket();
  36.     
  37.     
  38.       SOCKET s_;
  39.     
  40.       int* refCounter_;
  41.     
  42.     private:
  43.       static void Start();
  44.       static void End();
  45.       static int  nofSockets_;
  46.  
  47. };
  48.  
  49.  
  50. class SocketClient : public Socket
  51. {
  52.     public:
  53.       SocketClient(const std::string& host, int port);
  54. };
  55.  
  56.  
  57.  
  58. class SocketServer : public Socket
  59. {
  60.     public:
  61.       SocketServer(int port, int connections, TypeSocket type=BlockingSocket);
  62.     
  63.       Socket* Accept();
  64. };
  65.  
  66.  
  67. // http: //msdn.microsoft .com/library/default.asp?url=/library/en-us/winsock/wsapiref_2tiq.asp
  68. class SocketSelect {
  69.   public:
  70.     SocketSelect(Socket const * const s1, Socket const * const s2=NULL, TypeSocket type=BlockingSocket);
  71.  
  72.     bool Readable(Socket const * const s);
  73.  
  74.   private:
  75.     fd_set fds_;
  76. };
  77.  
  78.  
  79. #endif
  80.  
  81.  


-----------------------------|  socket.cpp  |--------------------
Código: Text
  1. #include <SOCKET.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6.  
  7. int Socket::nofSockets_= 0;
  8.  
  9.  
  10. void Socket::Start()
  11. {
  12.   if (!nofSockets_)
  13.   {
  14.     WSADATA info;
  15.     if (WSAStartup(MAKEWORD(2,0), &info))
  16.     {
  17.       throw "Could not start WSA";
  18.     }
  19.   }
  20.   ++nofSockets_;
  21. }
  22.  
  23.  
  24. void Socket::End()
  25. {
  26.   WSACleanup();
  27. }
  28.  
  29.  
  30. Socket::Socket() : s_(0)
  31. {
  32.   Start();
  33.   // UDP: use SOCK_DGRAM instead of SOCK_STREAM
  34.   s_ = socket(AF_INET,SOCK_STREAM,0);
  35.  
  36.   if (s_ == INVALID_SOCKET)
  37.   {
  38.     throw "INVALID_SOCKET";
  39.   }
  40.  
  41.   refCounter_ = new int(1);
  42. }
  43.  
  44.  
  45. Socket::Socket(SOCKET s) : s_(s)
  46. {
  47.   Start();
  48.   refCounter_ = new int(1);
  49. };
  50.  
  51.  
  52. Socket::~Socket()
  53. {
  54.   if (! --(*refCounter_))
  55.   {
  56.     Close();
  57.     delete refCounter_;
  58.   }
  59.  
  60.   --nofSockets_;
  61.   if (!nofSockets_) End();
  62. }
  63.  
  64.  
  65. Socket::Socket(const Socket& o)
  66. {
  67.   refCounter_=o.refCounter_;
  68.   (*refCounter_)++;
  69.   s_         =o.s_;
  70.  
  71.   nofSockets_++;
  72. }
  73.  
  74.  
  75. Socket& Socket::operator=(Socket& o)
  76. {
  77.   (*o.refCounter_)++;
  78.  
  79.   refCounter_=o.refCounter_;
  80.   s_         =o.s_;
  81.  
  82.   nofSockets_++;
  83.  
  84.   return *this;
  85. }
  86.  
  87.  
  88. void Socket::Close()
  89. {
  90.   closesocket(s_);
  91. }
  92.  
  93.  
  94. std::string Socket::ReceiveBytes()
  95. {
  96.   std::string ret;
  97.   char buf[1024];
  98.  
  99.   while (1) {
  100.     u_long arg = 0;
  101.     if (ioctlsocket(s_, FIONREAD, &arg) != 0)
  102.     {
  103.       break;
  104.     }
  105.  
  106.     if (arg == 0)
  107.     {
  108.       break;
  109.     }
  110.     
  111.     if (arg > 1024)
  112.     {
  113.             arg = 1024;
  114.     }
  115.  
  116.     int rv = recv (s_, buf, arg, 0);
  117.  
  118.     if (rv <= 0)
  119.     {
  120.            break;
  121.     }
  122.  
  123.     std::string t;
  124.  
  125.     t.assign (buf, rv);
  126.     ret += t;
  127.   }
  128.  
  129.   return ret;
  130. }
  131.  
  132.  
  133. std::string Socket::ReceiveLine()
  134. {
  135.   std::string ret;
  136.   while (1)
  137.   {
  138.     char r;
  139.  
  140.     switch(recv(s_, &r, 1, 0))
  141.     {
  142.       case 0: // not connected anymore;
  143.               // ... but last line sent
  144.               // might not end in \n,
  145.               // so return ret anyway.
  146.         return ret;
  147.  
  148.       case -1:
  149.         return "";
  150. //      if (errno == EAGAIN) {
  151. //        return ret;
  152. //      } else {
  153. //      // not connected anymore
  154. //      return "";
  155. //      }
  156.     }
  157.  
  158.     ret += r;
  159.     if (r == '\n')  return ret;
  160.   }
  161. }
  162.  
  163.  
  164. void Socket::SendLine(std::string s)
  165. {
  166.   s += '\n';
  167.   send(s_,s.c_str(),s.length(),0);
  168. }
  169.  
  170.  
  171. void Socket::SendBytes(const std::string& s)
  172. {
  173.   send(s_,s.c_str(),s.length(),0);
  174. }
  175.  
  176.  
  177. SocketServer::SocketServer(int port, int connections, TypeSocket type)
  178. {
  179.   sockaddr_in sa;
  180.  
  181.   memset(&sa, 0, sizeof(sa));
  182.  
  183.   sa.sin_family = PF_INET;            
  184.   sa.sin_port = htons(port);          
  185.   s_ = socket(AF_INET, SOCK_STREAM, 0);
  186.   if (s_ == INVALID_SOCKET)
  187.   {
  188.     throw "INVALID_SOCKET";
  189.   }
  190.  
  191.   if(type==NonBlockingSocket)
  192.   {
  193.     u_long arg = 1;
  194.     ioctlsocket(s_, FIONBIO, &arg);
  195.   }
  196.  
  197.   /* bind the socket to the internet address */
  198.   if (bind(s_, (sockaddr *)&sa, sizeof(sockaddr_in)) == SOCKET_ERROR)
  199.   {
  200.     closesocket(s_);
  201.     throw "INVALID_SOCKET";
  202.   }
  203.   
  204.   listen(s_, connections);                              
  205. }
  206.  
  207.  
  208. Socket* SocketServer::Accept()
  209. {
  210.   SOCKET new_sock = accept(s_, 0, 0);
  211.   if (new_sock == INVALID_SOCKET)
  212.   {
  213.     int rc = WSAGetLastError();
  214.     if(rc==WSAEWOULDBLOCK)
  215.     {
  216.       return 0; // non-blocking call, no request pending
  217.     }
  218.     else
  219.     {
  220.       throw "Invalid Socket";
  221.     }
  222.   }
  223.  
  224.   Socket* r = new Socket(new_sock);
  225.   return r;
  226. }
  227.  
  228.  
  229. SocketClient::SocketClient(const std::string& host, int port) : Socket()
  230. {
  231.   std::string error;
  232.  
  233.   hostent *he;
  234.   if ((he = gethostbyname(host.c_str())) == 0)
  235.   {
  236.     error = strerror(errno);
  237.     throw error;
  238.   }
  239.  
  240.   sockaddr_in addr;
  241.   addr.sin_family = AF_INET;
  242.   addr.sin_port = htons(port);
  243.   addr.sin_addr = *((in_addr *)he->h_addr);
  244.   memset(&(addr.sin_zero), 0, 8);
  245.  
  246.   if (::connect(s_, (sockaddr *) &addr, sizeof(sockaddr)))
  247.   {
  248.     error = strerror(WSAGetLastError());
  249.     throw error;
  250.   }
  251. }
  252.  
  253.  
  254. SocketSelect::SocketSelect(Socket const * const s1, Socket const * const s2, TypeSocket type)
  255. {
  256.   FD_ZERO(&fds_);
  257.   FD_SET(const_cast<Socket*>(s1)->s_,&fds_);
  258.   if(s2)
  259.   {
  260.     FD_SET(const_cast<Socket*>(s2)->s_,&fds_);
  261.   }    
  262.  
  263.   TIMEVAL tval;
  264.   tval.tv_sec  = 0;
  265.   tval.tv_usec = 1;
  266.  
  267.   TIMEVAL *ptval;
  268.   if(type==NonBlockingSocket)
  269.   {
  270.     ptval = &tval;
  271.   }
  272.   else
  273.   {
  274.     ptval = 0;
  275.   }
  276.  
  277.   if (select (0, &fds_, (fd_set*) 0, (fd_set*) 0, ptval) == SOCKET_ERROR)
  278.     throw "Error in select";
  279. }
  280.  
  281. bool SocketSelect::Readable(Socket const* const s)
  282. {
  283.   if (FD_ISSET(s->s_,&fds_)) return true;
  284.   return false;
  285. }
  286.  
  287.  


-----------------------------|  tipos.h  |--------------------
Código: Text
  1. //                              DEFINICION DE TIPOS
  2.  
  3. typedef unsigned int Tpdu_L2CAP [1200]; // Dato de entrada, PDU L2CAP  
  4.  
  5.  
  6.  
  7. typedef struct {
  8.   unsigned int Code;
  9.   unsigned int ID;
  10.   int Length;
  11.   int PSM;
  12.   int SCID;
  13. } TL2CAP_con_req;    // Connection Request packet
  14.  
  15. typedef struct {
  16.   unsigned int Code;
  17.   unsigned int ID;
  18.   int Length;
  19.   int DCID;
  20.   int SCID;
  21.   int Result;
  22.   int Status;
  23. } TL2CAP_con_res;   // Connection Response packet
  24.  
  25.  

-----------------------------|  constantes.h  |--------------------
Código: Text
  1. // Codigos de los comandos de señalizacion
  2.  
  3. #define L2CAP_CONREQ 0x02
  4. #define L2CAP_CONRES 0x03
  5.  
  6.  
  7. // Estados definidos en la máquina de estados
  8.  
  9. #define CLOSED 0x00
  10. #define WAIT_CONNECT 0x01
  11. #define WAIT_CONNECT_RSP 0x02
  12. #define CONFIG 0x03   // Consta de un numero de sub estados
  13. #define OPEN 0x04
  14. #define WAIT_DISCONNECT 0x05
  15.  
  16. // Sub estados dentro del estado CONFIG
  17.  
  18. #define WAIT_CONFIG 0x06
  19. #define WAIT_SEND_CONFIG 0x07
  20. #define WAIT_CONFIG_REQ_RSP 0x08
  21. #define WAIT_CONFIG_RSP 0x09
  22. #define WAIT_CONFIG_REQ 0x10
  23.  
  24. // Eventos
  25.  
  26. #define OPENCHANNEL_REQ 0x01
  27. #define OPENCHANNEL_RSP 0x02
  28. #define CONNECTREQ 0x03
  29. #define CONNECTRSP 0x04
  30.  
  31.  


-----------------------------|  principal.cpp  |--------------------
Código: Text
  1. #include <cstdlib>
  2. #include <iostream>
  3. #include <L2cap.h>
  4. #include <windows.h>
  5.  
  6. using namespace std;
  7.  
  8.  
  9. int main()
  10. {
  11.   int msg,opcion;
  12.   std::string cadena;
  13.     msg = 0;
  14.     
  15.     do
  16.   {
  17.     system("cls");
  18.     opcion = 0;
  19.     cout <<endl<<"                *-----------------------------------------*";
  20.     cout <<endl<<"                |        B  L  U  E  T  O  O  T  H        |";
  21.     cout <<endl<<"                *-----------------------------------------*";
  22.     cout <<endl<<"                |       M E N U   L 2 C A P   v 2.1.      |";
  23.     cout <<endl<<"                *-----------------------------------------*";
  24.     cout <<endl<<"                |                                         |";
  25.     cout <<endl<<"                |  1.- Modo Servidor................. (1) |";
  26.     cout <<endl<<"                |  2.- Modo Cliente manda PDU........ (2) |";
  27.         cout <<endl<<"                |  3.- Salir......................... (3) |";
  28.     cout <<endl<<"                |                                         |";
  29.     cout <<endl<<"                *-----------------------------------------*"<<endl<<endl<<endl;
  30.     cout <<endl<<"                  >  Elija una Opcion.......... ";
  31.     scanf("%d",&opcion);
  32.  
  33.   }while (opcion < 1 || opcion > 3);
  34.  
  35.   //Lee Menu y llama funciones
  36.   switch(opcion)
  37.     {            
  38.          case 1:
  39.              {
  40.               system("cls");
  41.               L2cap micapa(1);
  42.               while (1)
  43.               {
  44.                     cout<<"Sigo aqui en modo Servidor..."<<endl;
  45.                     Sleep(4000);  
  46.                 }
  47.                 break;
  48.              }
  49.  
  50.          case 2:
  51.              {
  52.               system("cls");
  53.               L2cap micapa(2);
  54.                 
  55.                 micapa.Openchannel_req ();
  56.                 
  57.                 //micapa.sendRaw();  
  58.                 // Si utilizo sendRaw desde aquí, SI funciona la comunicación
  59.                 //por Socket de client a Serv, pero no de Serv a cliente (el canal no escribe por socket)
  60.                 
  61.                 while (1)
  62.                 {
  63.                    cout<<"Sigo aqui en modo Cliente..."<<endl;
  64.                    Sleep(4000);  
  65.                  }
  66.               system("pause");
  67.               break;
  68.              }
  69.     
  70.         case 3:
  71.             {
  72.                 system("cls");
  73.               L2cap micapa(3);                
  74.                 micapa.Salir();
  75.                 cout <<endl<<"                >  FIN DEL PROGRAMA.........."<<endl<<endl;
  76.             break;
  77.         }
  78.     }
  79.   return 0;
  80. }  
  81.  
  82.  


-----------------------------|  l2cap.h  |--------------------
Código: Text
  1. //#include <Socket.h>
  2. #include <L2capChannel.h>
  3. #include <vector>
  4. #include <string>
  5. #include <sstream>
  6. #include <iostream>
  7. #include <cstdlib>
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10.  
  11. using namespace std;
  12.  
  13.  
  14.                    // DEFINICION DE TIPOS
  15.  
  16. typedef struct
  17. {
  18.     unsigned int CID;
  19.   unsigned int PSM;
  20.   int funcptr;
  21. } Ttabla;
  22.  
  23.  
  24. typedef L2capChannel *Tpcanal;
  25.  
  26.  
  27.  
  28. class L2cap
  29. {
  30.  
  31.  public:
  32.         
  33.      L2cap (int mode);  // Constructor.
  34.      ~L2cap (); // Destructor.
  35.      void Salir ();    
  36.      void Send_Data(std::string cadena); // Modo Cliente        
  37.      void Server(int argc, char* argv[]); // Modo Servidor
  38.      void leerSocketClient();
  39.      void leerSocketServer();
  40.      void leerSocket();
  41.      void sendRaw();
  42.      bool escuchando();
  43.  
  44.      void escribeEnSocket(std::string cadena);
  45.      static void Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena);
  46.  
  47.  
  48.      int Openchannel_req ();
  49.  
  50.  
  51.  private:    
  52.                        // VARIABLES GLOBALES
  53.      Socket *s;
  54.      bool _escuchando;
  55.      vector<Ttabla> tabla;
  56.      vector<L2capChannel*> canales;
  57.     
  58.       
  59.                          //     FUNCIONES
  60.  
  61.         void string_to_bytearray (std::string str, unsigned int* &array, int& size);
  62.  
  63.         unsigned int Leertipotrama (Tpdu_L2CAP datain);
  64.         static unsigned __stdcall bucleLectura(void* a);
  65.         void Analiza_contenido(std::string r);
  66.         int BuscaTabla(int cid);
  67.         void ImprimeTabla();
  68.         int AsignaCID(void);
  69. };
  70.  
  71.  


-----------------------------|  l2cap.cpp  |--------------------
Código: Text
  1. #include <L2cap.h>
  2. #include <Socket.h>
  3. #include <vector>
  4. #include <process.h>
  5. #include <string>
  6. #include <sstream>
  7. #include <iostream>
  8. #include <cstdlib>
  9. #include <stdio.h>
  10.  
  11. using namespace std;
  12.  
  13.  
  14. bool L2cap::escuchando()
  15. {
  16.      return _escuchando;
  17. }
  18.  
  19.  
  20. unsigned __stdcall L2cap::bucleLectura(void* a)
  21. {
  22.   L2cap *thisL2cap = (L2cap*)a;
  23.     
  24.   while (thisL2cap->escuchando())
  25.   {
  26.     cout<<endl<<"Esperando Nuevos datos..."<<endl;
  27.     thisL2cap->leerSocket();
  28.   }
  29.   return 0;
  30. }
  31.  
  32.  
  33. L2cap::L2cap (int mode)  // Constructor
  34. {
  35.    _escuchando = true;
  36.  
  37.    if (mode==1) // Modo Servidor
  38.    {
  39.    SocketServer in(3000,5);
  40.    Socket* sa=in.Accept();
  41.    s = sa;
  42.    cout<<"Conexion Recibida"<<endl;      
  43.  
  44.    unsigned ret;
  45.    _beginthreadex(0,0,bucleLectura,(void*)this,0,&ret);
  46.    }
  47.  
  48.    else if (mode==2) // Modo Cliente
  49.    {
  50.    SocketClient sb("pc.", 3000);
  51.    s = &sb;
  52.    *(s) = sb; //Con esto hemos anclado el contenido del puntero y ya no se borra al salir del Constructor
  53.  
  54.  
  55.    unsigned ret;
  56.    _beginthreadex(0,0,bucleLectura,(void*)this,0,&ret);
  57.    }
  58. } //Ctor
  59.  
  60.  
  61.  
  62. L2cap::~L2cap ()  // Destructor
  63. {
  64. }
  65.  
  66.  
  67.  
  68. void L2cap::string_to_bytearray(std::string str, unsigned int* &array, int& size)
  69. {
  70.   int length = str.length();
  71.   // nos aseguramos de que la cadena entrante tiene un número de elementos par
  72.   if(length%2 == 1)
  73.   {
  74.     str = "0" + str;
  75.     length++;
  76.   }
  77.   // Reservamos memoria para el array de salida  
  78.   array = new unsigned int[length/2];
  79.   size = length/2;
  80.  
  81.   std::stringstream sstr(str);
  82.  
  83.   for(int i=0; i < size; i++)
  84.   {
  85.     char ch1, ch2;
  86.     sstr >> ch1 >> ch2;
  87.     unsigned int dig1, dig2;
  88.     if(isdigit(ch1)) dig1 = ch1 - '0';
  89.     else if(ch1>='A' && ch1<='F') dig1 = ch1 - 'A' + 10;
  90.     else if(ch1>='a' && ch1<='f') dig1 = ch1 - 'a' + 10;
  91.     if(isdigit(ch2)) dig2 = ch2 - '0';
  92.     else if(ch2>='A' && ch2<='F') dig2 = ch2 - 'A' + 10;
  93.     else if(ch2>='a' && ch2<='f') dig2 = ch2 - 'a' + 10;
  94.     array[i] = dig1*16 + dig2;
  95.   }
  96. }
  97.  
  98.  
  99.  
  100. unsigned int L2cap::Leertipotrama(Tpdu_L2CAP datain)    
  101. {
  102.   unsigned int tipo;
  103.  
  104.   if ((*(datain+2)==0x01)&(*(datain+3)==0x00))  
  105.   {
  106.     tipo = 'C'; // Trama de control. c-frame
  107.   }
  108.   else if ((*(datain+2)==0x02)&(*(datain+3)==0x00))
  109.   {
  110.     tipo = 'G'; // Trama G. Canal no orientado a conexión
  111.   }
  112.   else if ((*(datain+2)>=0x40))
  113.   {
  114.     tipo = 'B';  // Trama-B
  115.   }
  116.   else
  117.   {
  118.     tipo = 'N'; // Tipo no válido
  119.   }
  120.   return tipo;
  121. }
  122.  
  123.  
  124. void L2cap::Salir () // Funcion que manda por socket la cadena salir que hace que salga del bucle infinito Server
  125. {
  126.    int i;
  127.   
  128.    SocketClient s("pc.", 3000); //No hace falta crear el socket de nuevo
  129.    std::string c1 = "exit";
  130.    s.SendBytes(c1);
  131. }
  132.  
  133.  
  134. int L2cap::BuscaTabla(int cid)
  135. {
  136.     int bus=-1;
  137.     for (int i=0; i<tabla.size();i++)
  138.     {
  139.         if (tabla[i].CID==cid)
  140.         {
  141.            bus=i;
  142.         }
  143.     }
  144.     return bus;
  145.     //Si no ha encontrado registrado en la tabla el CID buscado, devuelve -1,
  146.     //En caso de q lo encuentre, devuelve la posicion en la que se encuentra el
  147.     //canal con dicho CID
  148. }
  149.  
  150.  
  151. void L2cap::ImprimeTabla()
  152. {
  153.     printf("\n\n----TABLA DE REGISTRO DE CANALES L2CAP----\n");
  154.     for (int i=0; i<tabla.size();i++)
  155.     {
  156.         printf("tabla [%d].CID = %X \n",i,tabla[i].CID);
  157.         printf("tabla [%d].PSM = %X \n\n",i,tabla[i].PSM);
  158.     }
  159. }
  160.  
  161.  
  162.  
  163. int L2cap::AsignaCID()
  164. //Busca, para una trama de datos (B), que CID hay libre para asignarle
  165. //a la comunicación actual
  166. {
  167.     int nuevoCID=0x40;
  168.     while (BuscaTabla(nuevoCID)>=0)
  169.     {
  170.           printf("Ya esta registrado el CID de valor %X \n",nuevoCID);
  171.           nuevoCID++;
  172.     }
  173.     printf("Registrado con exito el CID de valor %X \n",nuevoCID);
  174.     return nuevoCID; //Devuelve el 1ero que no esta en la tabla
  175. }
  176.  
  177.  
  178. void L2cap::Analiza_contenido(std::string r)
  179. {
  180.     unsigned int longitud, tipo;
  181.      unsigned int* datain = NULL;
  182.     int size,CID,bus,num;
  183.  
  184.     size = r.length();
  185.     if (size>0)
  186.     {  
  187.       if (r =="exit")
  188.       {
  189.           _escuchando = false;
  190.           cout<<"Escuchando se ha puesto a false"<<endl;
  191.       }
  192.       else
  193.       {
  194.           cout <<"Recibida una string de longitud "<<r.length()<<endl<<"y contenido: "<<r<<endl<<endl;                
  195.           string_to_bytearray(r,datain,size);
  196.           
  197.           longitud = size-4; // se trata del campo length, mientras q size es toda.
  198.         
  199.           tipo = Leertipotrama (datain);
  200.         
  201.           switch (tipo)
  202.             {
  203.             case 'C' :  // Se trata de una trama-C
  204.               {    
  205.                 printf("Es una trama C \n \n");
  206.                      // Primero vemos de que comando se trata
  207.                            int code = *(datain+4);
  208.                           
  209.                            if (code==L2CAP_CONREQ)
  210.                            {
  211.                              //Creamos un canal nuevo, actualizamos tabla,...
  212.                            int receivedPSM = *(datain+8) + (*(datain+9))*256;
  213.                              CID = AsignaCID(); //Asignamos nuevo CID
  214.                              cout<<"Recibida Connection Request"<<endl;
  215.  
  216.                              canales.push_back(new L2capChannel(CID,receivedPSM,s)); //puntero a socket
  217.                              Ttabla elementoTabla;
  218.                              elementoTabla.CID = CID;
  219.                              elementoTabla.PSM = receivedPSM;
  220.                              tabla.push_back(elementoTabla);
  221.                              ImprimeTabla();
  222.                            }
  223.                           
  224.                            else
  225.                            //Se trata de una: ConnectionRsp, ConfigReq,
  226.                            //ConfigRsp*, DiscReq
  227.                            {
  228.                                CID = *(datain+8) + (*(datain+9))*256;
  229.                            }
  230.                         
  231.                         bus=BuscaTabla(CID);
  232.                         if (bus >=0)
  233.                         {
  234.                            num=canales[bus]->entradaComandos(datain,longitud);
  235.                         }
  236.  
  237.                     break;
  238.                     }
  239.         
  240.             case 'G' :  // Se trata de una trama-G
  241.               {
  242.                     printf("Es una trama G \n \n");    
  243.               break;
  244.               }
  245.         
  246.             case 'B' : //Se trata de una trama-B
  247.               {
  248.                         printf("Es una trama B \n \n");
  249.                   break;
  250.               }
  251.                 
  252.                 case 'N':
  253.               {
  254.               printf("Trama no valida. \n \n");
  255.                   break;
  256.               }
  257.                 
  258.                 default :
  259.               {
  260.                 printf("Algo esta pasando... \n \n");
  261.               }
  262.                }        
  263.       }      
  264.     }
  265. }
  266.  
  267.  
  268.  
  269.  
  270. void L2cap::leerSocket()
  271. {
  272.      cout<<"Voy a leer"<<endl;
  273.  
  274.      std::string r = "";
  275.      while (r.length()==0)
  276.      {
  277.        r = s->ReceiveBytes();
  278.      }
  279.      Analiza_contenido(r);    
  280.      cout<<"Ya he leido"<<endl;
  281. }
  282.  
  283.  
  284.  
  285. void L2cap::sendRaw()
  286. {
  287.     std::string cadena="080001000205040001004000"; //Connection Request    
  288.     escribeEnSocket(cadena);
  289.     cout<<"He enviado una cadena"<<endl;
  290. }
  291.  
  292.  
  293. int L2cap::Openchannel_req ()
  294. {
  295.     int res = 0;
  296.     int PSM = 2;
  297.     int CID,bus,num;
  298.  
  299.      CID = AsignaCID();
  300.     
  301. // Metemos en el vector de canales un nuevo elemento Canal que creamos con su constructor
  302.  
  303. //     canales.push_back(new L2capChannel(CID,PSM,s)); // Puntero a socket
  304.      canales.push_back(new L2capChannel(CID,PSM,(void*)this,&Wrapper_a_escribeEnSocket)); // Callback
  305.     
  306.  
  307. // Metemos tambien los datos del canal que hemos creado para registrarlo en la tabla
  308.  
  309.      Ttabla elementoTabla;
  310.      elementoTabla.CID = CID;
  311.      elementoTabla.PSM = PSM;
  312.      tabla.push_back(elementoTabla);
  313.      ImprimeTabla();        
  314.  
  315.     bus=BuscaTabla(CID);
  316.     if (bus >=0)
  317.     {
  318.        num=canales[bus]->connectChannel(); // Llamamos a connectChannel dentro de L2capChannel
  319.     }
  320.     return res;
  321. }
  322.  
  323.  
  324. void L2cap::escribeEnSocket(std::string cadena)
  325. {
  326.      cout<<"Cadenita a mandar: "<<cadena<<endl;
  327.      s->SendBytes(cadena);
  328. }
  329.  
  330.  
  331.  
  332. void L2cap::Wrapper_a_escribeEnSocket (void* pt2Object, std::string cadena)
  333. {
  334.      cout<<"Welcome to WRAPPER"<<endl;
  335.        L2cap* mySelf = (L2cap*) pt2Object;
  336.        mySelf->escribeEnSocket(cadena);
  337.       
  338.       //mySelf->sendRaw();  // Esto debería de funcionar, pero tampoco
  339. }
  340.  
  341.  


-----------------------------|  l2capChannel.h  |--------------------
Código: Text
  1. #include <iostream>
  2. #include <string>
  3. #include <tipos.h>
  4. #include <constantes.h>
  5. #include <Socket.h>
  6.  
  7.  
  8. using namespace std;
  9.  
  10. class L2capChannel
  11. {
  12.  
  13.  
  14.  public:
  15.         
  16.          L2capChannel (int CID, int PSM,Socket* a);  // Constructor. Se encarga de la correcta inicializacion
  17.          L2capChannel (int CID, int PSM,void* a, void(*pt2Func)(void*, std::string));
  18.          ~L2capChannel ();
  19.          unsigned int Obtener_estado();
  20.  
  21.          int entradaComandos (Tpdu_L2CAP pdu, unsigned int longitud);
  22.          int connectChannel();
  23.         
  24.  private:        
  25.                        // VARIABLES GLOBALES
  26.  
  27.     unsigned int _estado; // Indica el estado en el que nos encontramos
  28.     unsigned int _leidos;
  29.     unsigned int _MTU_negociada;
  30.     unsigned int _MTU_sig; // de señalizacion
  31.     unsigned int _identifier, _receivedIdentifier;
  32.     int _localCID, _remoteCID, _PSM;
  33.     void* _ME;
  34.  
  35.     Socket* sockCanal;
  36.  
  37.  
  38.                       //Variables de cada tipo de comando
  39.  
  40.   TL2CAP_con_req L2CAPcon_req_TX, L2CAPcon_req_RX;
  41.   TL2CAP_con_res L2CAPcon_res_TX, L2CAPcon_res_RX;
  42.     
  43.  
  44.                          //     FUNCIONES
  45.     
  46.     void sendComando (unsigned int tipocomando);    
  47.     void imprimeArray (Tpdu_L2CAP datain, unsigned int longitud);
  48.  
  49.     
  50.                          // funciones de lectura de cada tipo de trama-C        
  51.         void leerL2CAPcon_req(Tpdu_L2CAP pdu, unsigned int &n);
  52.         int  leerL2CAPcon_res(Tpdu_L2CAP pdu, unsigned int &n);
  53.  
  54.         void imprimeComando (unsigned int codigo);
  55.     
  56.  
  57.     void escribeL2CAPcon_req_TX (void);
  58.     void escribeL2CAPcon_res_TX (int result);
  59.  
  60.     
  61.     void situacion ();
  62.         
  63.     void vuelcaL2CAPcon_req(Tpdu_L2CAP &dataout);
  64.     void vuelcaL2CAPcon_res(Tpdu_L2CAP &dataout);
  65.     
  66.     string arrayToString(Tpdu_L2CAP a);
  67.     bool Esnumero (char valor);
  68. };
  69.  
  70.  
  71.  

2
C/C++ / Stl Vector De Punteros
« en: Jueves 22 de Noviembre de 2007, 09:34 »
Quería utilizar la stl vector, en lugar de un array, para ir almacenando valores conforme voy necesitando, y no tener que usar un array reservando un número de posiciones y eso.
Los  vectores, con sus instrucciones push_back, size(), ... son bastante cómodos en ese aspecto.
Si lo que realizo es un vector de una variable normal, por decirlo de alguna manera, como un int, un registro con sus campos, ... no hay problema.

Código: Text
  1. vector <int> mivector;
  2.  
  3. mivector.push_back(3); //Almacena el valor 3 en el vector
  4.  
  5. tamaño = mivector.size(); //devuelve el tamaño que tiene actualmente
  6.  
  7.  
Cuando quiera acceder a un elemento en concreto de los que tiene almacenado el vector, puedo acceder a ellos mediante:

Código: Text
  1. elemento=mivector[indice];
  2.  
  3.  

Pero el problema me surge cuando lo que quiero almacenar en el vector no es una variable de ese tipo, sino que quiero almacenar punteros a una clase que tengo creada.
Mi programa va a ir creando nuevos elementos de dicha clase conforme lo va necesitando, y yo en mi vector quiero almacenar punteros a cada uno de los elementos de tipo clase que haya creado.

Ahora mi variable vector será:

Código: Text
  1. vector <*Tclase> mivector2;
  2.  
  3. *Tclase elementonuevo; // tendre que ir almacenando punteros a Tclase
  4. mivector2.push_back(elementonuevo);
  5.  
  6.  
y para trabajar con los métodos de mi clase, de uno de los elementos que tengo en el vector, tendré que hacer:

Código: Text
  1. mivector2[indice]->metododemiclase(parametro1, parametro2);
  2.  
  3.  
¿Es correcto el planteamiento? Es que no termino de tenerlo claro si las definiciones y los accesos a los  metodos de la clase se realizarían de esa manera.

Muchisimas gracias de antemano!  :)

3
C/C++ / Problema Con _beginthreadex En Una Clase
« en: Martes 6 de Noviembre de 2007, 08:05 »
Hola.

Es mi primer mensaje en el foro. Aprovecho para saludar y daros a todos las gracias por vuestra ayuda.

Soy un programador mas o menos novato, y no tengo mucha o ninguna idea de muchas, cosas, y bueno.

Vereis. Para la implementación del programa que estoy haciendo, he tenido que usar comunicación por sockets, para que se comuniquen dos entidades de mi programa.

Y para ello he usado una clase socket implementada, que contaba con ejemplos de servidor y de cliente.

El problema está en que estoy usando dicha clase socket, en una clase mia que me he creado.

El código de la clase socket, para un servidor, tal y como estaba definido por el autor de la clase es el siguiente (no es el que yo tengo en mi programa, que lo he puesto mas abajo):


Código: Text
  1. unsigned __stdcall Answer(void* a) {
  2.   Socket* s = (Socket*) a;
  3.  
  4.   while (1) {
  5.     std::string r = s->ReceiveLine();
  6.     if (r.empty()) break;
  7.     s->SendLine(r);
  8.   }
  9.  
  10.   delete s;
  11.  
  12.   return 0;
  13. }
  14.  
  15.  
  16. int main(int argc, char* argv[]) {
  17.   SocketServer in(2000,5);
  18.  
  19.   while (1) {
  20.     Socket* s=in.Accept();
  21.  
  22.     unsigned ret;
  23.     _beginthreadex(0,0,Answer,(void*) s,0,&ret);
  24.   }
  25.   
  26.   return 0;
  27. }
  28.  
  29.  




En mi programa, mi problema está en que yo estoy haciendo uso de dicha clase socket, y de actuar como servidor, dentro de una clase que me he creado. Y el problema que tengo es que, tras recibir datos por el socket, yo quiero comprobar si son un tipo de datos u otros, y uso variables globales pertenecientes a mi clase.


Para trabajar en mi clase tendre que declarar la función main como Nombremiclase::Server(int arg...).

Y para ver las variables globales desde la stdcall, supongo que tendré que ponerla en mi clase también...

No se, llevo varios dias intentandolo y estoy hundido, no hay manera. A ver si alguien supiese.



Os dejo el codigo que tengo implementado en mi clase, y el error que obtengo, que es :

In member function 'void L2cap::Server (int,char**)'
argument of type 'unsigned int (L2cap:: )(void*) does not match 'unsigned int (*)(void*)')
Buil error (L2cap.o) Error 1.

Código: Text
  1.  
  2. unsigned __stdcall L2cap::Answer(void* a)
  3. {
  4.   L2capChannel canal;
  5.   Socket* s = (Socket*) a;
  6.     unsigned int longitud, leidos, tipo, pos, NumBytes,opt;
  7.       unsigned int* datain = NULL;
  8.     int size;
  9.  
  10.  
  11.  
  12.   while (1) // escuchando
  13.   {
  14.     std::string r = s->ReceiveBytes();
  15.     
  16.     size = r.length();
  17.     L2cap::string_to_bytearray(r,datain,size);
  18.     
  19.  
  20.     Write(datain,size);
  21.  
  22.     longitud = size-4; // se trata del campo length, mientras q size es toda
  23.  
  24.  
  25.    tipo = Leertipotrama (datain);
  26.  
  27.     
  28.     if (r =="exit")
  29.     {
  30. //          escuchando = false;
  31. //          cout<<"Escuchando se ha puesto a false"<<endl;
  32.     }
  33.     else if ((r.length())>0)
  34.     {
  35.        cout <<"Recibida una string de longitud "<<r.length()<<endl<<"y contenido: "<<r<<endl<<endl;                
  36.        canal.EntradaDatos(r);
  37.     }
  38.  
  39. //    s->SendBytes(r);
  40.   }
  41.   delete s;
  42.  
  43.   return 0;
  44. }
  45.  
  46.  
  47.  
  48. void L2cap::Server(int argc, char* argv[]) // Modo Servidor
  49. {
  50.   SocketServer in(3000,5);
  51.  
  52.   while (escuchando)
  53.   {
  54.     Socket* s=in.Accept();
  55.  
  56.     unsigned ret;
  57.     _beginthreadex(0,0,L2cap::Answer,(void*) s,0,&ret);
  58.   }
  59. }
  60.  
  61.  


Ojalá podais ayudarme, muchísimas gracias de antemano.

Un saludo.

Páginas: [1]