Grid Application Toolkit A simple API for Grid Applications

Menu Home API-Specification API-Overview Status C Reference Manual Download Java Java-Reference General GridLab - WP-1 Links

endpoint.c Go to the documentation of this file. /** @file adaptor.c * Main file for the endpoint adaptor. * * Test adaptor to check the GATEndpoint API. Provides a simple file GATEndpointCPI implementation. * * @date $Date: 2004/05/13 09:52:23 $ * * @version $Header: /export/cvs-gridlab/GridLabWeb/WorkPackages/wp-1/Doc/C-Reference/endpoint_8c-source.html,v 1.6 2004/05/13 09:52:23 merzky Exp $ * * Copyright (C) Kelly Davis * This file is part of the GAT Engine. * Contributed by Kelly Davis <kdavis@aei.mpg.de>. * * Use, modification and distribution is subject to the Gridlab Software * License. (See accompanying file GLlicense.txt or copy at * http://www.gridlab.org/GLlicense.txt) */ static const char *rcsid = "$Header: /export/cvs-gridlab/GridLabWeb/WorkPackages/wp-1/Doc/C-Reference/endpoint_8c-source.html,v 1.6 2004/05/13 09:52:23 merzky Exp $"; /* System Header Files */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* POSIX Header Files */ #include <unistd.h> #if !defined(WIN32) #include <arpa/inet.h> #include <netdb.h> #endif #include <sys/types.h> #include <sys/socket.h> #include <netinet/in.h> /* GAT Header Files */ #include <GATCPI.h> /* Adaptor Header Files */ #include "Common.h" #include "endpoint.h" /* Macros */ #define ENDPOINT_ADAPTOR_PORT 1227 #define __countof(x) (sizeof(x)/sizeof(x[0])) /* Structures, unions and enums */ #if defined(WIN32) /* Adaptor data */ typedef struct GATEndpointCPIAdaptor_Data { WSADATA wsadata; } GATEndpointCPIAdaptor_Data; #endif /* Instance data */ typedef struct GATEndpointInstance_Data { int local_socket; struct sockaddr_in socketAddress; int server_port; int client_port; GATPipeListener listener; void *callBackData; } GATEndpointInstance_Data; /* Static function prototypes */ static void endpoint_adaptor_EndpointCPI_Destroy(void *data); /* instance specific functions */ GATResult endpoint_adaptor_EndpointCPI_CreateInstance(void *adaptor_data, GATEndpointCPI_Instance *data); void endpoint_adaptor_EndpointCPI_DestroyInstance(void *adaptor_data, GATEndpointCPI_Instance *data); GATResult endpoint_adaptor_EndpointCPI_CloneInstance(void *adaptor_data, GATEndpointCPI_Instance const *data, GATEndpointCPI_Instance *new_data); GATResult endpoint_adaptor_EndpointCPI_EqualsInstance(void *adaptor_data, GATEndpointCPI_Instance const *lhs, GATEndpointCPI_Instance const *rhs, GATBool *isequal); /* Serialisation functions */ static GATResult endpoint_adaptor_EndpointCPI_Serialise(void *data, GATEndpointCPI_Instance const *instance_data, GATObject stream, GATBool clear_dirty); static GATResult endpoint_adaptor_EndpointCPI_DeSerialise(void *data, GATObject stream, GATEndpointCPI_Instance *instance_data); /* CPI specific API */ static GATResult endpoint_adaptor_EndpointCPI_Connect(void *, GATEndpointCPI_Instance const *, GATPipe *); static GATResult endpoint_adaptor_EndpointCPI_Listen(void *, GATEndpointCPI_Instance const *, GATPipe *); static GATResult endpoint_adaptor_EndpointCPI_AddGATPipeListener(void *, GATEndpointCPI_Instance const *, GATPipeListener, void *); /* Execute a GATEndpoint get_metrics operation */ static GATResult endpoint_adaptor_EndpointCPI_GetMetrics(void *data, GATEndpointCPI_Instance const *instance_data, GATList_GATMetric *metrics); /* Execute a GATEndpoint get_metric_event operation */ static GATResult endpoint_adaptor_EndpointCPI_GetMetricEvent(void *data, GATEndpointCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event); /* local helper functions */ static GATResult endpoint_adaptor_FireConnect(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult endpoint_adaptor_FireListen(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name); static GATResult endpoint_adaptor_FireAddGATPipeListener(GATMonitorable_Impl monitorable, GATObject_const source, char const *name); #if defined(WIN32) /* Adaptor data */ static GATEndpointCPIAdaptor_Data *GATEndpointCPIAdaptor_Data_Create(); static void GATEndpointCPIAdaptor_Data_Destroy(GATEndpointCPIAdaptor_Data *); #endif // defined(WIN32) /* File scope variables */ static GATStaticMetric metric_data[] = { /* endpoint.connect event */ { "endpoint.connect", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* endpoint.listen event */ { "endpoint.listen", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ }, /* endpoint.addgatpipelistener event */ { "endpoint.addgatpipelistener", /* name */ GATMeasurementType_EventLike, /* type */ GATType_String, /* data type */ "", /* unit */ 0, /* parameter count */ 0 /* parameters */ } }; /* symbolic constants for the metric positions inside the metric_data array */ #define METRIC_FILESTREAM_CONNECT 0 #define METRIC_FILESTREAM_LISTEN 1 #define METRIC_FILESTREAM_ADDGATPIPELISTENER 2 /* External functions */ /** endpoint_adaptor_register * Registers all CPIs this adaptor provides. * This function is invoked by the loader in the GATEngine when * an instance of this adaptor is loaded. Each instance has its * own private configuration table. * * For every CPI provided the adapter has to hand all the corresponding * function pointers to the engine to allow to be called back under certain * circumstances. Additionally the adaptor may allocate some private data for * every loaded instance. This data is handed back to the adaptor as the first * parameter to each of the subsequently called functions. * * @param registry The registry the adaptor should register its CPIs with. * @param system_config The system configuration table. * @param instance_config The configuration table for this instance. * @param token An arbitrary token used by the loader to identify this adaptor * instance * * @return An error code. */ GATResult endpoint_adaptor_register_endpoint(GATContext error_context, GATRegistry registry, GATTable_const system_config, GATTable_const instance_config, void *token) { GAT_USES_STATUS(error_context, "endpoint_adaptor_register_endpoint"); GATEndpointCPI cpi = NULL; GATEndpointCPI_Data cpidata; #if defined(WIN32) GATEndpointCPIAdaptor_Data *adaptor_data = GATEndpointCPIAdaptor_Data_Create(); #endif GAT_UNUSED_PARAMETER(system_config); GAT_UNUSED_PARAMETER(instance_config); memset(&cpidata, 0, sizeof(GATEndpointCPI_Data)); /* * provide the appropriate callback functions */ #if defined(WIN32) if (NULL != adaptor_data) #endif { /* adaptor instance data */ #if defined(WIN32) cpidata.data = adaptor_data; #else cpidata.data = NULL; #endif cpidata.destroy = endpoint_adaptor_EndpointCPI_Destroy; /* Lifetime control and basic GATObject functionality support for every * object instance created by the client. */ cpidata.create_instance = endpoint_adaptor_EndpointCPI_CreateInstance; cpidata.destroy_instance = endpoint_adaptor_EndpointCPI_DestroyInstance; cpidata.clone_instance = endpoint_adaptor_EndpointCPI_CloneInstance; cpidata.equals_instance = endpoint_adaptor_EndpointCPI_EqualsInstance; /* serialisation support functions */ cpidata.serialise = endpoint_adaptor_EndpointCPI_Serialise; cpidata.deserialise = endpoint_adaptor_EndpointCPI_DeSerialise; /* CPI support */ cpidata.connect = endpoint_adaptor_EndpointCPI_Connect; cpidata.listen = endpoint_adaptor_EndpointCPI_Listen; cpidata.addPipeListener = endpoint_adaptor_EndpointCPI_AddGATPipeListener; /* monitoring support */ cpidata.get_metrics = endpoint_adaptor_EndpointCPI_GetMetrics; cpidata.get_metric_event = endpoint_adaptor_EndpointCPI_GetMetricEvent; /* Create a GATEndpointCPI object. */ cpi = GATEndpointCPI_Create(GATFILESTREAMCPI_VERSION, &cpidata); if(NULL != cpi) { /* Need to pass preferences to allow matching * of a user's preferences with what this adaptor does. */ GATPreferences preferences = GATPreferences_Create(); if(NULL != preferences) { GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Name", "endpoint_adaptor")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Security", "none")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Local", "true")); GAT_CREATE_STATUS(GATRegistry_AddGATEndpointCPI(registry, cpi, token, preferences)); GATPreferences_Destroy(&preferences); } } } #if defined(WIN32) else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } #endif if (GAT_FAILED(GAT_CURRENT_STATUS())) { #if defined(WIN32) if (NULL == cpi) { GATEndpointCPIAdaptor_Data_Destroy(adaptor_data); } else #endif { GATEndpointCPI_Destroy(&cpi); } } return GAT_RETURN_STATUS(); } /* Local functions */ /** endpoint_adaptor_EndpointCPI_Destroy * Destroy the adaptor-provided data object on GATEndpointCPI destruction. * When the GATEndpointCPI object created in this adaptor's _register * function is destroyed, this function is invoked to allow the * adaptor to cleanup. * * @param data Adaptor-provided data object. */ static void endpoint_adaptor_EndpointCPI_Destroy(void *data) { #if defined(WIN32) GATEndpointCPIAdaptor_Data_Destroy((GATEndpointCPIAdaptor_Data *) data); #endif } /** endpoint_adaptor_EndpointCPI_CreateInstance * Create a new CPI object instance. * Adaptor implementation of create instance capability. * * @param adaptor_data Adaptor-provided data object. * @param data The pointer to the data structure containing at least * the constructor provided data items and a member instance_data, which * may be used by the adaptor to store CPI instance specific data. * * @return An error code. */ GATResult endpoint_adaptor_EndpointCPI_CreateInstance(void *adaptor_data, GATEndpointCPI_Instance *data) { GAT_UNUSED_PARAMETER(adaptor_data); if (NULL != data) { GAT_USES_STATUS(data->context, "endpoint_adaptor_EndpointCPI_CreateInstance"); if (NULL != data) { GATEndpointInstance_Data *gatEndpointInstance_Data = (GATEndpointInstance_Data *) malloc(sizeof(GATEndpointInstance_Data)); if (NULL != gatEndpointInstance_Data) { memset(gatEndpointInstance_Data, 0, sizeof(GATEndpointInstance_Data)); gatEndpointInstance_Data->listener = NULL; gatEndpointInstance_Data->callBackData = NULL; gatEndpointInstance_Data->local_socket = socket(AF_INET, SOCK_STREAM, 0); if (0 <= gatEndpointInstance_Data->local_socket) { int bindResult; gatEndpointInstance_Data->socketAddress.sin_family = AF_INET; gatEndpointInstance_Data->socketAddress.sin_addr.s_addr = htonl(INADDR_ANY); gatEndpointInstance_Data->socketAddress.sin_port = htons(ENDPOINT_ADAPTOR_PORT); gatEndpointInstance_Data->server_port = ENDPOINT_ADAPTOR_PORT; bindResult = bind(gatEndpointInstance_Data->local_socket, (struct sockaddr *)&gatEndpointInstance_Data->socketAddress, sizeof(struct sockaddr_in)); if (0 <= bindResult) { data->instance_data = (void *) gatEndpointInstance_Data; } else { GAT_CREATE_STATUS(GAT_FAIL); close(gatEndpointInstance_Data->local_socket); free(gatEndpointInstance_Data); } } else { GAT_CREATE_STATUS(GAT_FAIL); free(gatEndpointInstance_Data); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** endpoint_adaptor_EndpointCPI_DestroyInstance * Destroy a CPI object instance. * Adaptor implementation of destroy instance capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of the CPI object to destroy. */ void endpoint_adaptor_EndpointCPI_DestroyInstance(void *adaptor_data, GATEndpointCPI_Instance *data) { GAT_UNUSED_PARAMETER(adaptor_data); if( (NULL != data) && (NULL != data->instance_data) ) { GATEndpointInstance_Data *gatEndpointInstance_Data; gatEndpointInstance_Data = (GATEndpointInstance_Data *) data->instance_data; close( gatEndpointInstance_Data->local_socket ); free( gatEndpointInstance_Data ); } } /** endpoint_adaptor_EndpointCPI_CloneInstance * Clone a CPI object instance. * Adaptor implementation of the clone instance capability. * * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object * @param new_instance_data The pointer to the variable, where the instance * data of the cloned CPI object is to be returned to. * * @return An error code. */ GATResult endpoint_adaptor_EndpointCPI_CloneInstance(void *adaptor_data, GATEndpointCPI_Instance const *instance_data, GATEndpointCPI_Instance *new_instance_data) { GAT_UNUSED_PARAMETER(adaptor_data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "endpoint_adaptor_EndpointCPI_CloneInstance"); if (NULL != new_instance_data) { if (NULL != instance_data->instance_data) { GATEndpointInstance_Data *newInstance_Data = (GATEndpointInstance_Data *)malloc(sizeof(GATEndpointInstance_Data)); if (NULL != newInstance_Data) { struct GATEndpointInstance_Data *oldInstance_Data = (GATEndpointInstance_Data *) instance_data->instance_data; memset(newInstance_Data, 0, sizeof(GATEndpointInstance_Data)); newInstance_Data->listener = oldInstance_Data->listener; newInstance_Data->local_socket = oldInstance_Data->local_socket; newInstance_Data->callBackData = oldInstance_Data->callBackData; memcpy (&newInstance_Data->socketAddress, &oldInstance_Data->socketAddress, sizeof(struct sockaddr_in)); new_instance_data->instance_data = newInstance_Data; } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { new_instance_data->instance_data = NULL; GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** endpoint_adaptor_EndpointCPI_EqualsInstance * Clone a CPI object instance. * Adaptor implementation of the clone instance capability. * * @param data Adaptor-provided data object. * @param lhs The instance data of the left CPI object. * @param lhs The instance data of the right CPI object. * @param isequal The pointer to the variable, where the result is to be * returned to. * * @return An error code. */ GATResult endpoint_adaptor_EndpointCPI_EqualsInstance(void *data, GATEndpointCPI_Instance const *lhs, GATEndpointCPI_Instance const *rhs, GATBool *isequal) { GATResult retval = GAT_INVALID_HANDLE; GAT_UNUSED_PARAMETER(data); if ( (NULL != isequal) && (NULL != lhs) && (NULL != rhs) ) { GATEndpointInstance_Data *lhsGATEndpointInstance_Data; GATEndpointInstance_Data *rhsGATEndpointInstance_Data; lhsGATEndpointInstance_Data = (GATEndpointInstance_Data *) lhs->instance_data; rhsGATEndpointInstance_Data = (GATEndpointInstance_Data *) rhs->instance_data; if( (NULL != lhsGATEndpointInstance_Data) && (NULL != rhsGATEndpointInstance_Data) ) { *isequal = GATFalse; retval = GAT_SUCCESS; if (lhsGATEndpointInstance_Data->local_socket == rhsGATEndpointInstance_Data->local_socket) { *isequal = GATFalse; retval = GAT_SUCCESS; if (lhsGATEndpointInstance_Data->socketAddress.sin_port == rhsGATEndpointInstance_Data->socketAddress.sin_port) { *isequal = GATFalse; retval = GAT_SUCCESS; if (lhsGATEndpointInstance_Data->socketAddress.sin_family == rhsGATEndpointInstance_Data->socketAddress.sin_family) { *isequal = GATFalse; retval = GAT_SUCCESS; if (lhsGATEndpointInstance_Data->listener == rhsGATEndpointInstance_Data->listener) { *isequal = GATFalse; retval = GAT_SUCCESS; if (lhsGATEndpointInstance_Data->callBackData == rhsGATEndpointInstance_Data->callBackData) { *isequal = GATTrue; retval = GAT_SUCCESS; } } } } } } else { *isequal = GATFalse; retval = GAT_SUCCESS; if (NULL == lhsGATEndpointInstance_Data && NULL == rhsGATEndpointInstance_Data) { *isequal = GATTrue; retval = GAT_SUCCESS; } } } return retval; } /* Serialization functions */ /** endpoint_adaptor_EndpointCPI_Serialise * * The function endpoint_adaptor_EndpointCPI_Serialise is called by the * GAT engine, whenever the client requested a Serialise operation on the * corresponding GATendpoint object. The function should serialise into the * given stream all the instance specific data of the object. * * @param cpi The GATEndpoint CPI * @param data Adaptor-provided data object. * @param instance_data The instance data of this CPI object. * @param stream The GATSTream object to use for serialisation of the instance data. * @param clear_dirty This flag defines, whether the dirty flag of saved dependent objects is to be cleared. * * @return An error code */ static GATResult endpoint_adaptor_EndpointCPI_Serialise(void *data, GATEndpointCPI_Instance const *instance_data, GATObject stream, GATBool clear_dirty) { GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(stream); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "endpoint_adaptor_EndpointCPI_Serialise"); /* this adaptor has to serialise the server port used (the nodename is serialised by the engine) */ GATEndpointInstance_Data *gatEndpointInstance_Data = (GATEndpointInstance_Data *)instance_data->instance_data; GAT_CREATE_STATUS(GATuint32_Serialise(gatEndpointInstance_Data->server_port, stream)); return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** endpoint_adaptor_EndpointCPI_DeSerialise * * The function endpoint_adaptor_EndpointCPI_DeSerialise is called by * the GATEngine, whenever the client requested a DeSerialise operation for * a GATEndpoint object. The function should deserialise all the instance * specific data of the object from the given stream. * * @param cpi The GATEndpoint CPI * @param data Adaptor-provided data object. * @param stream The GATSTream object to use for de-serialisation of the * instance data. * @param instance_data The instance data of this CPI object. * * @return An error code */ static GATResult endpoint_adaptor_EndpointCPI_DeSerialise(void *data, GATObject stream, GATEndpointCPI_Instance *instance_data) { GAT_UNUSED_PARAMETER(data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "endpoint_adaptor_EndpointCPI_DeSerialise"); GATEndpointInstance_Data *gatEndpointInstance_Data = (GATEndpointInstance_Data *) malloc(sizeof(GATEndpointInstance_Data)); if (NULL != gatEndpointInstance_Data) { GATuint32 port = 0; memset(gatEndpointInstance_Data, 0, sizeof(GATEndpointInstance_Data)); GAT_CREATE_STATUS(GATuint32_DeSerialise(stream, &port)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { gatEndpointInstance_Data->server_port = port; gatEndpointInstance_Data->local_socket = socket(AF_INET, SOCK_STREAM, 0); if (0 <= gatEndpointInstance_Data->local_socket) { int bindResult; gatEndpointInstance_Data->socketAddress.sin_family = AF_INET; gatEndpointInstance_Data->socketAddress.sin_addr.s_addr = htonl(INADDR_ANY); gatEndpointInstance_Data->socketAddress.sin_port = 0; bindResult = bind(gatEndpointInstance_Data->local_socket, (struct sockaddr *)&gatEndpointInstance_Data->socketAddress, sizeof(struct sockaddr_in)); if (0 <= bindResult) { /* get the port number back (needed later on) */ struct sockaddr_in client_addr; int len = sizeof(struct sockaddr_in); memset(&client_addr, 0, sizeof(struct sockaddr_in)); getsockname(gatEndpointInstance_Data->local_socket, (struct sockaddr *)&client_addr, &len); gatEndpointInstance_Data->client_port = ntohs(client_addr.sin_port); instance_data->instance_data = gatEndpointInstance_Data; } else { GAT_CREATE_STATUS(GAT_FAIL); close(gatEndpointInstance_Data->local_socket); free(gatEndpointInstance_Data); } } else { GAT_CREATE_STATUS(GAT_FAIL); free(gatEndpointInstance_Data); instance_data->instance_data = NULL; } } else { free(gatEndpointInstance_Data); instance_data->instance_data = NULL; } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /* CPI support */ /** endpoint_adaptor_EndpointCPI_Connect * This function connects to this endpoint's server instance. * This is the adaptor implementation of the connect capability. * * @param data Adaptor-provided data object. * @param instance_data Instance data of the CPI object * @param peep The created GATPipe * @return An error code. */ static GATResult endpoint_adaptor_EndpointCPI_Connect(void *data, GATEndpointCPI_Instance const *instance_data, GATPipe *peep) { GAT_UNUSED_PARAMETER(data); if (NULL != instance_data) { GAT_USES_STATUS(instance_data->context, "endpoint_adaptor_EndpointCPI_Connect"); if (NULL != instance_data && NULL != peep) { GATPreferences preferences; preferences = GATPreferences_Create(); if (NULL != preferences) { GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Name", "pipe_adaptor")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Security", "none")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Local", "true")); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATEndpointInstance_Data *gatEndpointInstance_Data = (GATEndpointInstance_Data *)instance_data->instance_data; if (NULL != gatEndpointInstance_Data && 0 != gatEndpointInstance_Data->local_socket) { struct sockaddr_in serverAddress; struct hostent *hostend = NULL; memset(&serverAddress, 0, sizeof(serverAddress)); serverAddress.sin_family = AF_INET; hostend = gethostbyname(instance_data->nodename); serverAddress.sin_addr = *((struct in_addr *)hostend->h_addr); serverAddress.sin_port = htons(gatEndpointInstance_Data->server_port); if (INADDR_NONE != serverAddress.sin_addr.s_addr) { int connectReturn = connect(gatEndpointInstance_Data->local_socket, (struct sockaddr *) &serverAddress, sizeof(serverAddress)); if (0 <= connectReturn) { GATPipe newGATPipe = NULL; GATPipeAdaptorInfo gatPipeAdaptorInfo; gatPipeAdaptorInfo.isClientInfo = GATTrue; gatPipeAdaptorInfo.clientSocket = gatEndpointInstance_Data->local_socket; newGATPipe = GATPipe_Create(instance_data->context, preferences, &gatPipeAdaptorInfo); if (NULL != newGATPipe) { *peep = newGATPipe; GAT_CREATE_STATUS(endpoint_adaptor_FireConnect( instance_data->context, instance_data->monitorable, instance_data->source, "connect")); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } else { GAT_CREATE_STATUS(GAT_FAIL); } } } else { GAT_CREATE_STATUS(GAT_FAIL); } } GATPreferences_Destroy(&preferences); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } return GAT_RETURN_STATUS(); } return GAT_INVALID_HANDLE; } /** endpoint_adaptor_EndpointCPI_Listen * This function listens for connections to this endpoint's server. * This is the adaptor implementation of the listen capability. * * @param data Adaptor-provided data object. * @param instance_data Instance data of the CPI object * @param peep The created GATPipe * @return An error code. */ static GATResult endpoint_adaptor_EndpointCPI_Listen(void *data, GATEndpointCPI_Instance const *instance_data, GATPipe *peep) { GAT_USES_STATUS(instance_data->context, "endpoint_adaptor_EndpointCPI_Listen"); GAT_UNUSED_PARAMETER(data); if (NULL != instance_data && NULL != peep) { if (NULL != instance_data->instance_data) { int listenReturn = -1; GATEndpointInstance_Data *gatEndpointInstance_Data = (GATEndpointInstance_Data *) instance_data->instance_data; listenReturn = listen (gatEndpointInstance_Data->local_socket, 1); if (0 == listenReturn) { int length = sizeof(gatEndpointInstance_Data->socketAddress); int clientSocket = 0; clientSocket = accept(gatEndpointInstance_Data->local_socket, (struct sockaddr *) &(gatEndpointInstance_Data->socketAddress), &length); if (-1 != clientSocket) { GATPreferences preferences = GATPreferences_Create(); if (NULL != preferences) { GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Name", "pipe_adaptor")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Security", "none")); GAT_CREATE_STATUS(GATPreferences_Add(preferences, "Local", "true")); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATPipe newGATPipe; GATPipeAdaptorInfo gatPipeAdaptorInfo; gatPipeAdaptorInfo.isClientInfo = GATFalse; gatPipeAdaptorInfo.clientSocket = clientSocket; newGATPipe = GATPipe_Create (instance_data->context, preferences, (void *) &gatPipeAdaptorInfo); if (NULL != newGATPipe) { *peep = newGATPipe; GAT_CREATE_STATUS(endpoint_adaptor_FireListen( instance_data->context, instance_data->monitorable, instance_data->source, "listen")); if (NULL != gatEndpointInstance_Data->listener) { /* Temporary resting place for this code!!! */ GAT_CREATE_STATUS(gatEndpointInstance_Data->listener( gatEndpointInstance_Data->callBackData, newGATPipe)); } } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } GATPreferences_Destroy(&preferences); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } } } else { GAT_CREATE_STATUS(GAT_FAIL); } } else { GAT_CREATE_STATUS(GAT_INVALID_STATE); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** endpoint_adaptor_EndpointCPI_AddGATPipeListener * This function registers the passed listener to listen for the connection * of clients to this endpoint server. This is the adaptor implementation * of the AddGATPipeListener functionality. * * @param data Adaptor-provided data object. * @param instance_data Instance data of the CPI object * @param peepListener GATPipeListener object which handles incoming connections * @param listenerData Call back data * @return An error code. */ static GATResult endpoint_adaptor_EndpointCPI_AddGATPipeListener(void *data, GATEndpointCPI_Instance const *instance_data, GATPipeListener listener, void *callBackData) { GATResult retval = GAT_INVALID_PARAMETER; GAT_UNUSED_PARAMETER(data); if( (NULL != instance_data) && (NULL != listener) ) { if( NULL != instance_data->instance_data ) { GATEndpointInstance_Data *gatEndpointInstance_Data; gatEndpointInstance_Data = (GATEndpointInstance_Data *) instance_data->instance_data; gatEndpointInstance_Data->listener = listener; gatEndpointInstance_Data->callBackData = callBackData; retval = GAT_SUCCESS; endpoint_adaptor_FireAddGATPipeListener(instance_data->monitorable, instance_data->source, "addgatpipelistener"); } else { retval = GAT_INVALID_STATE; } } return retval; } /* Monitoring support */ /** endpoint_adaptor_EndpointCPI_GetMetrics * * The function endpoint_adaptor_EndpointCPI_GetMetrics should return a * list of GATMetric objects supported by this adaptor. I.e. the adaptor is * capable to fire GATMetricEvents for the returned metrics. This list should * include all the supported metrics, event like and continuous ones. * * @param data Adaptor-provided data object. * @param instance_data Instance data for the CPI provider object. * @param metrics The pointer to the variable, which receives the returned * list of metrics. * * @return An error code. */ static GATResult endpoint_adaptor_EndpointCPI_GetMetrics(void *data, GATEndpointCPI_Instance const *instance_data, GATList_GATMetric *metrics) { GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(instance_data); return GATMetric_CreateListOfMetrics(metric_data, __countof(metric_data), metrics); } /** endpoint_adaptor_EndpointCPI_GetMetricEvent * * The function endpoint_adaptor_EndpointCPI_GetMetricEvent should * return the GATMetricEvent associated with the given continuous metric. This * function gets called for continuous metrics only, since returning the * metric event object to the caller is th only way for the client to get * access to it. * * @param data Adaptor-provided data object. * @param instance_data Instance data for the CPI provider object. * @param metric The metric instance describing the metric event to return. * This metric should be equivalent to one of the metrics returned by * our own GetMetrics CPI function (see above). If this is another * (not known to us metric), an error should be returned. * @param event The pointer to the variable, which receives the metric event * to return. * * @return An error code. */ static GATResult endpoint_adaptor_EndpointCPI_GetMetricEvent(void *data, GATEndpointCPI_Instance const *instance_data, GATMetric metric, GATMetricEvent *event) { /* this adaptor supports no continuous metrics */ GAT_UNUSED_PARAMETER(data); GAT_UNUSED_PARAMETER(instance_data); GAT_UNUSED_PARAMETER(metric); GAT_UNUSED_PARAMETER(event); return GAT_SUCCESS; } /** endpoint_adaptor_FireConnect * * The function endpoint_adaptor_FireConnect fires a * 'endpoint connect' event to all registered metric listeners. */ static GATResult endpoint_adaptor_FireConnect(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GAT_USES_STATUS(context, "endpoint_adaptor_FireConnect"); if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; GAT_CREATE_STATUS(GATMetric_CreateMetric( &metric_data[METRIC_FILESTREAM_CONNECT], &metric)); if (GAT_SUCCEEDED(GAT_CURRENT_STATUS())) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { GAT_CREATE_STATUS(GATMonitorable_Impl_FireEvent(monitorable, metric, event)); GATMetricEvent_Destroy(&event); } else { GAT_CREATE_STATUS(GAT_MEMORYFAILURE); } GATMetric_Destroy(&metric); } } else { GAT_CREATE_STATUS(GAT_INVALID_PARAMETER); } return GAT_RETURN_STATUS(); } /** endpoint_adaptor_FireListen * * The function endpoint_adaptor_FireWriteEvent fires a * 'endpoint listen' event to all registered metric listeners. */ static GATResult endpoint_adaptor_FireListen(GATContext context, GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; retval = GATMetric_CreateMetric(&metric_data[METRIC_FILESTREAM_LISTEN], &metric); if (GAT_SUCCESS == retval) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { retval = GATMonitorable_Impl_FireEvent(monitorable, metric, event); } else { retval = GAT_MEMORYFAILURE; } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } return retval; } /** endpoint_adaptor_FireAddGATPipeListener * * The function endpoint_adaptor_FireSeekEvent fires a * 'endpoint add gat pipe listener' event to all registered metric listeners. */ static GATResult endpoint_adaptor_FireAddGATPipeListener(GATMonitorable_Impl monitorable, GATObject_const source, char const *name) { GATResult retval = GAT_INVALID_PARAMETER; if (NULL != monitorable && NULL != source && NULL != name) { GATMetric metric = NULL; retval = GATMetric_CreateMetric(&metric_data[METRIC_FILESTREAM_ADDGATPIPELISTENER], &metric); if (GAT_SUCCESS == retval) { GATMetricEvent event = GATMetricEvent_Create_EventLike(source, metric, (void *)name, (GATuint32)(strlen(name) + 1)); if (NULL != event) { retval = GATMonitorable_Impl_FireEvent(monitorable, metric, event); } else { retval = GAT_MEMORYFAILURE; } GATMetricEvent_Destroy(&event); GATMetric_Destroy(&metric); } } return retval; } #if defined(WIN32) /* Adaptor instance specific functions */ /** GATEndpointCPIAdaptor_Data_Create * This helper creates an instance of a GATEndpointCPIAdaptor_Data object. * * @return The newly created and initialized GATEndpointCPIAdaptor_Data object. */ static GATEndpointCPIAdaptor_Data *GATEndpointCPIAdaptor_Data_Create() { GATEndpointCPIAdaptor_Data *data = (GATEndpointCPIAdaptor_Data *)malloc(sizeof(GATEndpointCPIAdaptor_Data)); if (NULL != data) { int result = WSAStartup(MAKEWORD(2, 2), &data->wsadata); if (0 != result) { free(data); data = NULL; } if (LOBYTE(data->wsadata.wVersion) != 2 || HIBYTE(data->wsadata.wVersion) != 2) { WSACleanup(); free(data); data = NULL; } } return data; } /** GATEndpointCPIAdaptor_Data_Destroy * This helper destroys an instance of a GATEndpointCPIAdaptor_Data object. * * @param The GATEndpointCPIAdaptor_Data object to destroy */ static void GATEndpointCPIAdaptor_Data_Destroy(GATEndpointCPIAdaptor_Data *data) { if (NULL != data) { WSACleanup(); free(data); } } #endif // defined(WIN32)