gSOAP

gSOAP ^{[ 1 ] [ 2 ]} es un conjunto de herramientas de desarrollo de software en C y C++ para servicios web SOAP / XML y enlaces de datos XML genéricos . A partir de un conjunto de declaraciones de tipo C/C++, las herramientas gSOAP basadas en compilador generan rutinas de serialización en el código fuente para una serialización XML eficiente de las estructuras de datos C y C++ especificadas. La serialización no requiere ninguna copia adicional.

El kit de herramientas gSOAP comenzó como un proyecto de investigación en la Universidad Estatal de Florida por el profesor Robert van Engelen en 1999. El proyecto introdujo nuevos métodos ^{[ 2 ]} para el análisis XML altamente eficiente (análisis pull) ^{[ 3 ] [ 4 ]} y la serialización de datos C/C++ directamente en XML y posteriormente también en SOAP . El proyecto tuvo éxito ^{[ 5 ]} en definir enlaces de datos con seguridad de tipos entre tipos de esquema XML y una amplia variedad de tipos de datos C/C++ . El kit de herramientas utiliza programación automática para simplificar el desarrollo e invocación de servicios web utilizando serializadores XML autogenerados eficientes para enviar y recibir datos C/C++ directamente. Una herramienta basada en compilador específica del dominio genera código fuente que convierte eficientemente estructuras de datos nativas de C/C++ a XML y viceversa. ^{[ 1 ]} El kit de herramientas se desarrolló aún más para admitir el protocolo de mensajería de servicios web SOAP, introducido aproximadamente al mismo tiempo, de ahí el nombre " gSOAP " ( XML y SOAP genéricos ) y para utilizar el enfoque para el intercambio de datos científicos. ^{[ 6 ]} El desarrollo y mantenimiento posterior del software se llevó a cabo bajo la propiedad de Genivia Inc. Esto incluye la adición de nuevas capacidades de procesamiento de WSDL y XML Schema , así como la adición de muchas capacidades del protocolo de servicios web WS-* tales como optimizaciones de WS-Security, ^{[ 7 ]} mensajería XML-RPC , soporte para el formato de datos JSON , módulos de complemento para integrar gSOAP en servidores web Apache e IIS, y complementos de terceros tales como para Grid Services. ^{[ 8 ] [ 9 ]} El kit de herramientas gSOAP está escrito en C/C++ portable y utiliza una forma de arranque mediante la generación de su propio código para implementar un convertidor que traduce las especificaciones WSDL/XSD a código fuente C/C++ para enlaces de metadatos WSDL/XSD. El software gSOAP está licenciado bajo la licencia de código abierto GPLv2 y licencias de código fuente para uso comercial. El software gSOAP se utiliza ampliamente en proyectos industriales ^{[ 10 ]} e infraestructuras de misión crítica.

Un ejemplo de operación de servicio web en C para recuperar la tarifa de alojamiento de un hotel dado un número de huéspedes se puede declarar en forma anotada como

//Espacio de nombres del servicio gsoap ns: tempuri //Estilo del servicio gsoap ns: document //Codificación del servicio gsoap ns: literal int ns__get_rate ( char * hotel , int guests , float * rate );

El último parámetro de la función es siempre el valor de retorno del servicio, que puede denotarse como void para operaciones unidireccionales y debe ser una estructura o clase para agrupar varios parámetros de retorno del servicio. El valor de retorno entero de la función se utiliza para el diagnóstico de errores.

Una invocación de servicio en C utilizando la función autogenerada soap_call_ns__get_rate se ejecuta de la siguiente manera:

const char * URL = "http://www.example.com/hotels" ; const char * action = NULL ; struct soap * ctx = soap_new (); // nuevo contexto float rate ; int err = soap_call_ns__get_rate ( ctx , URL , action , "Happy Inn" , 2 , & rate ); if ( err == SOAP_OK && rate < 100.00 ) lets_go (); soap_end ( ctx ); // liberar datos deserializados soap_free ( ctx ); // liberar contexto

Para facilitar la implementación de servicios web en sistemas C y C++ heredados, se puede omitir el prefijo de los nombres de identificadores en C/C++ o sustituirlo por la notación de dos puntos; por ejemplo, `ns:get_rate` en lugar de `ns__get_rate`. La puntuación se elimina en el código fuente autogenerado que se utiliza en las compilaciones del proyecto.

Una invocación de servicio en C++ utilizando la clase Proxy autogenerada se ejecuta de la siguiente manera (utilizando la URL de punto final predeterminada del Proxy y los valores de acción SOAP):

Proxy proxy ; float rate ; int err = proxy.get_rate ( "Happy Inn" , 2 , & rate ) ; if ( err == SOAP_OK && rate < 100.00 ) lets_go ( ); proxy.destroy ( ); // liberar datos deserializados

Mediante el uso de anotaciones y convenciones de nomenclatura de identificadores, es decir, la calificación con el prefijo ns__ para la función ns__get_rate y la declaración de propiedades del espacio de nombres ns mediante las directivas //gsoap del ejemplo, se establece una vinculación con las operaciones del servicio web. El documento WSDL (Web Services Description Language) autogenerado declara un mensaje de solicitud, un mensaje de respuesta y la interfaz portType de la operación get-rate, así como la vinculación SOAP para la función ns__get_rate, de la siguiente manera:

<definiciones nombre= "Servicio" targetNamespace= "tempuri" xmlns:tns= "tempuri" xmlns:ns= "tempuri" xmlns= "http://schemas.xmlsoap.org/wsdl/" > ... <message name= "get-rateRequest" > <part name= "parameters" element= "ns:get-rate" /> </message> <message name= "get-rateResponse" > <part name= "parameters" element= "ns:get-rateResponse" /> </message><portType name= "ServicePortType" > <operation name= "get-rate" > <input message= "tns:get-rateRequest" /> <output message= "tns:get-rateResponse" /> </operation> </portType><binding name= "Service" type= "tns:ServicePortType" > <SOAP:binding style= "document" transport= "http://schemas.xmlsoap.org/soap/http" /> <operation name= "get-rate" > <SOAP:operation soapAction= "" /> <input> <SOAP:body parts= "parameters" use= "literal" /> </input> <output> <SOAP:body parts= "parameters" use= "literal" /> </output> </operation> </binding>

donde los mensajes de solicitud y respuesta de la operación hacen referencia a elementos XML que se definen en la sección de tipos del WSDL de la siguiente manera:

<types> <schema targetNamespace= "tempuri" ... > <element name= "get-rate" > <complexType> <sequence> <element name= "hotel" type= "xsd:string" minOccurs= "0" maxOccurs= "1" nillable= "true" /> <element name= "guests" type= "xsd:int" minOccurs= "1" maxOccurs= "1" /> </sequence> </complexType> </element> <element name= "get-rateResponse" > <complexType> <sequence> <element name= "rate" type= "xsd:float" minOccurs= "0" maxOccurs= "1" nillable= "true" /> </sequence> </complexType> </element> </schema> </types>

Asimismo, el código fuente C/C++ del cliente y del servidor se puede generar automáticamente a partir de un conjunto de WSDL y esquemas XML. Los servicios deben completarse definiendo las operaciones de servicio adecuadas. Por ejemplo, la clase de servicio C++ generada automáticamente para este WSDL debe completarse definiendo el método get_rate de la siguiente manera:

int Service::get_rate ( char * hotel , int guests , float * rate ) { * rate = ... // determina la tarifa de alojamiento del hotel en función del número de huéspedes return SOAP_OK ; }

No existen restricciones en cuanto al tipo de parámetros de operación que se pueden serializar en XML para la mensajería de servicios web, salvo que se deben seguir ciertas convenciones y anotaciones de declaración de tipos para establecer una vinculación de datos.

Para establecer una vinculación de datos XML con tipos de datos C/C++, gSOAP utiliza tres formas básicas de anotación de código fuente: directivas, convenciones de nomenclatura de identificadores y puntuación.

Una declaración de estructura completamente anotada en C para un registro jerárquico de empleados puede aparecer como

//Esquema gsoap ns espacio de nombres: tempuri //Formato del esquema gsoap ns: qualified struct ns__employee_record { @ char * xml__lang = "en" ; @ int ID = 9999 ; char * full_name 1 : 1 ; $int size 0 : 12 ; struct ns__employee_record * manages ; };

donde se utilizan las siguientes anotaciones y convenciones:

• Calificación de espacios de nombres de tipos y miembros mediante convenciones de nomenclatura de identificadores: ns__employee_record, xml__lang
• atributos para miembros: @char*, @int
• Valores predeterminados para los miembros: xml__lang = "en", ID = 9999
• Restricciones de ocurrencia en forma de minOccurs : maxOccurs para validación XML: full_name 1:1, size 0:12
• Los arreglos dinámicos de secuencias de elementos constan de un par formado por un campo de tamaño especial y un miembro puntero al arreglo: $int size; struct ns__employee_record *manages

Las herramientas gSOAP convierten tipos de datos C/C++ a/desde tipos de datos de esquema XML. Dado que C no admite espacios de nombres y los nombres de los miembros de las estructuras/clases no pueden estar calificados con espacios de nombres en C++, el uso de convenciones de nomenclatura de identificadores en gSOAP permite vincular esta estructura y sus miembros a un tipo complejo de esquema XML que se genera automáticamente de la siguiente manera:

<schema targetNamespace= "tempuri" xmlns:ns= "tempuri" xmlns:xsd= "http://www.w3.org/2001/XMLSchema" xmlns= "http://www.w3.org/2001/XMLSchema" elementFormDefault= "qualified" attributeFormDefault= "qualified" ><complexType name= "employee-record" > <sequence> <element name= "full-name" type= "xsd:string" minOccurs= "1" maxOccurs= "1" nillable= "true" /> <element name= "manages" type= "ns:employee-record" minOccurs= "0" maxOccurs= "12" /> </sequence> <attribute ref= "xml:lang" use= "default" default= "en" /> <attribute name= "ID" type= "xsd:int" use= "default" default= "9999" /> </complexType></esquema>

Además, las uniones en una estructura/clase que están anotadas con un campo selector especial para la selección de miembros de la unión se asignan a/desde partículas de elección de esquema, los contenedores STL se asignan a/desde partículas de secuencia, las enumeraciones se asignan a/desde enumeraciones simpleType de esquema XML, y los tipos primitivos estándar de C/C++ se asignan a/desde tipos XSD. Para la conversión de esquemas XSD a tipos de datos C/C++, la asignación real se puede configurar en gSOAP con un archivo de asignación de tipos.

Una instancia de la estructura jerárquica de empleados de ejemplo se serializa en XML como un árbol por defecto, por ejemplo

<ns:employee xmlns:ns= "tempuri " xml:lang= "en" ns:ID= " 12 " > <ns:full-name> Jane Doe </ns:full-name> <ns:manages xml:lang= "en" ns:ID= "34" > <ns:full-name> John Doe </ns:full-name> </ns:manages> <ns:manages xml:lang= "en" ns:ID= "56" > <ns:full-name> Bob Oz </ns:full-name> <ns:manages xml:lang= "en" ns:ID= "78" > <ns:full-name> Alice Oz </ns:full-name> </ns:manages> </ns:manages> </ns:employee>

Cuando se habilita el estilo de codificación SOAP, la serialización XML en gSOAP respeta los objetos correferenciados y las estructuras de datos cíclicas según las reglas de codificación SOAP, lo que da como resultado un XML con enlaces id-ref .

El enlace de datos XML autogenerado incluye operaciones de lectura y escritura hacia/desde un archivo, cadena o flujo. Por ejemplo, un objeto ns__employee_record tiene operaciones de lectura y escritura:

int soap_read_ns__employee_record ( struct soap * , ns__employee_record * ); int soap_write_ns__employee_record ( struct soap * , const ns__employee_record * );

Para leer el registro de un empleado desde un archivo XML:

struct soap * ctx = soap_new (); ctx -> recvfd = open ( "employee.xml" , O_RDONLY ); if ( ctx -> recvfd ) { ns__employee_record employee ; if ( soap_read_ns__employee_record ( ctx , & employee ) == SOAP_OK ) ... close ( ctx -> recvfd ); } soap_end ( ctx ); soap_destroy ( ctx ); // también elimina los datos del empleado soap_free ( ctx );

El XML analizado se valida internamente con respecto a las restricciones de los enlaces de datos.

Los datos de la aplicación se pueden enviar y recibir desde/hacia un servicio REST XML. El enlace de datos XML proporciona llamadas a la API REST XML. Por ejemplo, dado el enlace de datos XML ns__employee_record de la sección anterior, se generan automáticamente las siguientes operaciones GET, PUT y POST:

int soap_GET_ns__employee_record ( struct soap * , const char * URL , ns__employee_record * ); int soap_PUT_ns__employee_record ( struct soap * , const char * URL , const ns__employee_record * ); int soap_POST_send_ns__employee_record ( struct soap * , const char * URL , const ns__employee_record * ); int soap_POST_recv_ns__employee_record ( struct soap * , ns__employee_record * );

Las funciones POST deben llamarse conjuntamente: primero, POST_send para transmitir datos XML a la URL del punto final, seguido de POST_recv para aceptar los datos de respuesta (que pueden ser de un tipo diferente).

El XML recibido se valida internamente con respecto a las restricciones de los enlaces de datos.

• Enlace de datos XML para C y C++ basado en programación automática con generación de código fuente a fuente.
• Generación automática de código fuente cliente/servidor personalizable en ANSI C e ISO C++.
• Análisis XML de alta velocidad integrado y específico del esquema con validación XML
• Lenguaje de descripción de servicios web (WSDL) 1.1 y 2.0
• Servicios web SOAP 1.1 y 1.2
• Mecanismo de optimización de transmisión de mensajes en tiempo real (MTOM) y archivos adjuntos DIME/MIME
• Transferencia de estado representacional (REST) ​​HTTP(S) 1.0/1.1
• Verificado y compatible con los perfiles básicos WS-I 1.0a, 1.1 y 1.2.
• Patrones de esquema W3C verificados para la vinculación de datos , cobertura completa de patrones de prueba.
• XML-RPC para C y C++
• JSON para C y C++
• RSS 0,91, 0,92, 2,0
• WS-Security
• WS-Policy 1.2, 1.5 y WS-SecurityPolicy 1.2
• WS-Addressing 2003/03, 2004/03, 2005/03
• WS-ReliableMessaging 1.0 y 1.1
• WS-Discovery 1.0/1.1
• SOAP sobre UDP
• API Universal Description Discovery and Integration (UDDI) v2
• Autenticación HTTP básica y digest, autenticación NTLM , autenticación de proxy.
• IPv4 e IPv6 con SSL/TLS con almacenamiento en caché de sesiones SSL (basado en OpenSSL o GNUTLS )
• Compresión XML con gzip
• Módulos Apache 1.x y 2.0, módulos IIS ISAPI y WinInet , CGI y FastCGI
• Compatibilidad con servidores web independientes (multihilo, agrupación de conexiones)
• Gestión de memoria integrada con detección de desasignación y fugas.
• Arquitectura con complementos para capacidades adicionales
• Compatibilidad con internacionalización/localización (UTF8, UCS4, codificaciones MB, etc.)
• Compatible con cualquier plataforma y dispositivos pequeños (Symbian, VxWorks , Android, iPhone).

• Primeros pasos con gSOAP
• Página del proyecto en SourceForge
• Enlace de datos XML
• Publicación por entregas
• Lista de frameworks para servicios web
• Lista de especificaciones de servicios web