Subversion Repositories funbase_ip_library

/*

 * Copyright (c) 2010, Mentor Graphics Corporation

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * 1. Redistributions of source code must retain the above copyright notice,

 *    this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright notice,

 *    this list of conditions and the following disclaimer in the documentation

 *    and/or other materials provided with the distribution.

 * 3. Neither the name of the <ORGANIZATION> nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

 * POSSIBILITY OF SUCH DAMAGE.

 */

/*

*   FILENAME

*

*       create_svc.c

*

*

*************************************************************************/

#include "mcapid_support.h"

/************************************************************************

*

*   FUNCTION

*

*       MCAPID_Create_Service

*

*   DESCRIPTION

*

*       This function loops through a list of structures, performing

*       service requests based on the type of endpoint in each structure.

*       For each structure, a local endpoint is created and one of the

*       following functions performed:

*

*       Packet / Scalar Channel Client - If a service is specified, get

*       the endpoint associated with the service, create a connection,

*       and open the send side of the connection.

*

*       Packet / Scalar Channel Server - If a service is specified,

*       register the service with the registration node and open the

*       receive side of the connection.

*

*       Client Message - If a service is specified, get the endpoint

*       associated with the service.

*

*       Server Message - If a service is specified, register the service

*       with the registration node.

*

*   INPUTS

*

*       *mcapi_struct           A pointer to an array of MCAPID_STRUCT

*                               structures populated as follows:

*

*                               type - MCAPI_CHAN_PKT_TX_TYPE,

*                                      MCAPI_CHAN_PKT_RX_TYPE,

*                                      MCAPI_CHAN_SCL_TX_TYPE,

*                                      MCAPI_CHAN_SCL_RX_TYPE,

*                                      MCAPI_MSG_TX_TYPE,

*                                      MCAPI_MSG_RX_TYPE

*

*                               local_port - The local port to use or

*                               MCAPI_ANY_PORT if unspecified.

*

*                               *service - The name of the service to

*                               register if type is a _RX_; otherwise,

*                               the name of the service to get.

*

*                               retry - If type is _TX_, the number of

*                               times to retry the service get request.

*

*       count                   The number of elements in the mcapi_struct

*                               structure.

*

*   RETURN

*

*       None.  The status field of each MCAPID_STRUCT parameter will be

*       set according to the status of that service request.

*

*************************************************************************/

int MCAPID_Create_Service(MCAPID_STRUCT *mcapi_struct)

{

    mcapi_request_t request;

    int             retry;

    size_t          size;

    mcapi_status_t  status;

    static int      next_free_port = 20; /* arbitrary */

    int             rc = 0;

    /* Can't use MCAPI_PORT_ANY, because we need to know the port in order to

     * register it. */

    if (mcapi_struct->local_port == MCAPI_PORT_ANY) {

        mcapi_struct->local_port = next_free_port++;

    }

    /* Create the local endpoint. */

    mcapi_struct->local_endp = mcapi_create_endpoint(mcapi_struct->local_port,

                                                       &mcapi_struct->status);

    if (mcapi_struct->status == MCAPI_SUCCESS)

    {

        /* If a service was specified. */

        if (mcapi_struct->service)

        {

            /* Operate on the service field based on the type of endpoint. */

            switch (mcapi_struct->type)

            {

                /* Client type endpoints get services. */

                case MCAPI_CHAN_PKT_TX_TYPE:

                case MCAPI_CHAN_SCL_TX_TYPE:

                case MCAPI_MSG_TX_TYPE:

                    retry = mcapi_struct->retry;

                    do

                    {

                        /* Get the foreign endpoint. */

                        mcapi_struct->status =

                            MCAPID_Get_Service(mcapi_struct->service,

                                               &mcapi_struct->foreign_endp);

                        if (retry > 0)

                            retry --;

                        /* All attempts have been made. */

                        else if (retry != 0xffffffff)

                            break;

                    } while ( (mcapi_struct->status != MCAPI_SUCCESS) &&

                              (mcapi_struct->status != MCAPI_ERR_GENERAL) );

                    break;

                /* Server type endpoints register services. */

                case MCAPI_CHAN_PKT_RX_TYPE:

                case MCAPI_CHAN_SCL_RX_TYPE:

                case MCAPI_MSG_RX_TYPE:

                    /* Register the service. */

                    mcapi_struct->status =

                        MCAPID_Register_Service(mcapi_struct->service,

                                                mcapi_struct->node,

                                                mcapi_struct->local_port);

                    break;

                default:

                    break;

            }

        }

        /* If the service was registered / retrieved. */

        if (mcapi_struct->status == MCAPI_SUCCESS)

        {

            /* Operate on the structure based on the type of endpoint being

             * created.

             */

            switch (mcapi_struct->type)

            {

                /* The TX side of a packet channel. */

                case MCAPI_CHAN_PKT_TX_TYPE:

                    /* If a service was specified. */

                    if (mcapi_struct->service)

                    {

                        /* Issue the connection. */

                        mcapi_connect_pktchan_i(mcapi_struct->local_endp,

                                                mcapi_struct->foreign_endp,

                                                &request, &mcapi_struct->status);

                        /* Wait for the connection to complete. */

                        mcapi_wait(&request, &size, &mcapi_struct->status,

                                   MCAPI_TIMEOUT_INFINITE);

                    }

                    if (mcapi_struct->status == MCAPI_SUCCESS)

                    {

                        /* Open the TX side. */

                        mcapi_open_pktchan_send_i(&mcapi_struct->pkt_tx_handle,

                                                  mcapi_struct->local_endp,

                                                  &mcapi_struct->request,

                                                  &mcapi_struct->status);

                        mcapi_wait(&mcapi_struct->request, &size,

                                   &mcapi_struct->status, MCAPI_TIMEOUT_INFINITE);

                    }

                    break;

                case MCAPI_CHAN_PKT_RX_TYPE:

                    /* Open the RX side. */

                    mcapi_open_pktchan_recv_i(&mcapi_struct->pkt_rx_handle,

                                              mcapi_struct->local_endp,

                                              &mcapi_struct->request,

                                              &mcapi_struct->status);

                    mcapi_wait(&mcapi_struct->request, &size,

                               &mcapi_struct->status, MCAPI_TIMEOUT_INFINITE);

                    break;

                case MCAPI_CHAN_SCL_TX_TYPE:

                    /* If a service was specified. */

                    if (mcapi_struct->service)

                    {

                        /* Issue the connection. */

                        mcapi_connect_sclchan_i(mcapi_struct->local_endp,

                                                mcapi_struct->foreign_endp,

                                                &request, &mcapi_struct->status);

                        /* Wait for the connection to complete. */

                        mcapi_wait(&request, &size, &mcapi_struct->status,

                                   MCAPI_TIMEOUT_INFINITE);

                    }

                    if (mcapi_struct->status == MCAPI_SUCCESS)

                    {

                        /* Open the TX side. */

                        mcapi_open_sclchan_send_i(&mcapi_struct->scl_tx_handle,

                                                  mcapi_struct->local_endp,

                                                  &mcapi_struct->request,

                                                  &mcapi_struct->status);

                        mcapi_wait(&mcapi_struct->request, &size,

                                   &mcapi_struct->status, MCAPI_TIMEOUT_INFINITE);

                    }

                    break;

                case MCAPI_CHAN_SCL_RX_TYPE:

                    /* Open the RX side. */

                    mcapi_open_sclchan_recv_i(&mcapi_struct->scl_rx_handle,

                                              mcapi_struct->local_endp,

                                              &mcapi_struct->request,

                                              &mcapi_struct->status);

                    break;

                default:

                    break;

            }

            if (mcapi_struct->thread_entry)

            {

                /* Start the service locally. */

                MCAPID_Create_Thread(mcapi_struct->thread_entry, mcapi_struct);

            }

            else if (mcapi_struct->func)

            {

                rc = (int)mcapi_struct->func(mcapi_struct);

            }

        }

        /* If an error occurred. */

        if ( (mcapi_struct->status != MCAPI_SUCCESS) &&

             (mcapi_struct->status != MGC_MCAPI_ERR_NOT_CONNECTED) )

        {

            /* Delete the endpoint since the service could not be

             * registered / retrieved.  The call has failed for this

             * instance of the MCAPID_STRUCT.

             */

            mcapi_delete_endpoint(mcapi_struct->local_endp, &status);

        }

    }

    return rc;

} /* MCAPID_Create_Service */