Protocolos de comunicación de implementación en C/C++

Question

Estoy en el proceso de comenzar a implementar una pila de protocolos de comunicación propia en el software, pero no estoy seguro de dónde comenzar. Es el tipo de trabajo que no he hecho antes y estoy buscando ayuda en términos de recursos para los enfoques mejores/recomendados.

Utilizaré c/C++ y puedo usar librerías de uso (BSD/BOOST/Apache) pero no GPL. He usado C++ extensivamente así que usar las características de C++ no es un problema.

La pila de protocolos tiene tres capas y ya está completamente especificada y formalmente verificada. Entonces todo lo que tengo que hacer es implementarlo y probarlo completamente en los idiomas especificados. También debería mencionarse que el protocolo es muy simple, pero puede ejecutarse en diferentes dispositivos sobre una capa de transporte física confiable. Conozco los eventos, entradas, salidas, efectos secundarios y el comportamiento de las máquinas de estados de protocolo. En general, se recibe una interrupción para leer el mensaje recibido de la capa física para leerlo y enviarlo al dispositivo en espera. El dispositivo receptor puede procesar y pasar el mensaje de respuesta a la capa de protocolo para enviarlo a la capa física.

Cualquier ayuda con referencias/recomendaciones será apreciada. Estoy dispuesto a usar un lenguaje diferente solo para ayudarme a entender cómo implementarlos, pero eventualmente tendré que recurrir al lenguaje de elección.

Actualización: Un protocolo de ejemplo que deseo implementar es algo así como SNEP.

No necesito preocuparme por la administración de la conexión. Podemos suponer la conexión ya es establecer y que el protocolo hace es el intercambio de datos en los mensajes de protocolo ya están bien definidos en las especificaciones

Answer 1

Comience con interfaces y mensajes.

Declara las interfaces de sesión que permiten a los compañeros intercambiar mensajes. Declare los mensajes como estructuras de C++ con tipos simples, como ints, doubles, std :: string's y std :: vectores. Por ejemplo:

// these are your protocol messages 
struct HelloRequest { 
    uint32_t seq_no; 
    // more stuff 
}; 
struct HelloResponse { 
    uint32_t seq_no; 
    // more stuff 
}; 

// Session callback for received messages 
struct SessionReceiver { 
    virtual void connected(Session*) = 0; 
    virtual void receive(Session* from, HelloRequest msg) = 0; 
    virtual void receive(Session* from, HelloResponse msg) = 0; 
    virtual void disconnected(Session*) = 0; 
}; 

// Session interface to send messages 
struct Session { 
    virtual void send(HelloRequest msg) = 0; 
    virtual void send(HelloResponse msg) = 0; 
}; 

// this connects asynchronously and then calls SessionReceiver::connected() with a newly established session 
struct SessionInitiator { 
    virtual void connect(SessionReceiver* cb, std::string peer) = 0; 
}; 

// this accepts connections asynchronously and then calls SessionReceiver::connected() with a newly accepted session 
struct SessionAcceptor { 
    virtual void listen(SessionReceiver* cb, std::string port) = 0; 
}; 

continuación, pruebe la interfaz mediante la codificación de la lógica de negocio que utiliza estas interfaces. Una vez que esté seguro de que las interfaces le permiten implementar la lógica requerida, implemente las interfaces y la serialización de sus mensajes utilizando su marco de eventos preferido, como libevent o Boost.Asio.

Editar: Tenga en cuenta que las interfaces le permiten tener implementaciones simuladas o de prueba. Además, el hecho de que la serialización ocurra detrás de la interfaz significa que para los colegas en proceso no es necesario serializar ni deserializar los mensajes, puede pasarlos como están.

Answer 2

Boost.ASIO es vanguardia bastante cuando se trata de asíncrona (o sincrónica) de comunicación de red en C++

Answer 3

Eche un vistazo a Google Protocol Buffers.

partir de la descripción:

tampones protocolo son un mecanismo flexible, eficiente y automatizada para serializar datos estructurados - piensan XML, pero más pequeño, más rápido y más simple. Usted define cómo desea que sus datos se estructuren una vez, luego puede usar un código fuente especial generado para escribir y leer fácilmente sus datos estructurados desde y hacia una variedad de flujos de datos y usando una variedad de idiomas.Incluso puede actualizar su estructura de datos sin interrumpir los programas implementados que se compilan con el formato "antiguo".

Los búferes de protocolo son neutrales en el lenguaje y la plataforma, por lo que deben encajar en su proyecto. No pude encontrar la licencia, pero al menos no dice "GPL" en ninguna parte que pude encontrar.

Esto lo ayudará con los protocolos. Con la transmisión de datos real, bueno, a menos que esté escribiendo el sistema operativo usted mismo, debería haber algunos primitivos que debería usar. Es difícil dar una ayuda más exacta en la implementación a menos que proporcione un poco más de detalle. Por ejemplo, ¿qué canal de comunicación estás usando? Ethernet?

Pero como regla general, debe hacer que el ISR sea lo más corto posible. En este tipo de soluciones, generalmente significa copiar datos a un buffer de anillo. De esta forma, no tiene que asignar memoria en el ISR. ISR, después de haber copiado los datos, debe informar a las capas superiores del paquete. Si puedes usar DMA, úsalo. En ese caso, es posible enviar la notificación incluso antes de iniciar la transferencia de DMA.

Es posible que también desee comprobar Linux Device Drivers, chapter 10 en particular. Mira la parte de las mitades inferior y superior.