fwp/lib/frsh_fwp/fwp_fna.c

   1 /**************************************************************************/
   2 /* ---------------------------------------------------------------------- */
   3 /* Copyright (C) 2006 - 2008 FRESCOR consortium partners:                 */
   4 /*                                                                        */
   5 /*   Universidad de Cantabria,              SPAIN                         */
   6 /*   University of York,                    UK                            */
   7 /*   Scuola Superiore Sant'Anna,            ITALY                         */
   8 /*   Kaiserslautern University,             GERMANY                       */
   9 /*   Univ. Politécnica  Valencia,           SPAIN                        */
  10 /*   Czech Technical University in Prague,  CZECH REPUBLIC                */
  11 /*   ENEA                                   SWEDEN                        */
  12 /*   Thales Communication S.A.              FRANCE                        */
  13 /*   Visual Tools S.A.                      SPAIN                         */
  14 /*   Rapita Systems Ltd                     UK                            */
  15 /*   Evidence                               ITALY                         */
  16 /*                                                                        */
  17 /*   See http://www.frescor.org for a link to partners' websites          */
  18 /*                                                                        */
  19 /*          FRESCOR project (FP6/2005/IST/5-034026) is funded             */
  20 /*       in part by the European Union Sixth Framework Programme          */
  21 /*       The European Union is not liable of any use that may be          */
  22 /*       made of this code.                                               */
  23 /*                                                                        */
  24 /*                                                                        */
  25 /*  This file is part of FWP (Frescor WLAN Protocol)                      */
  26 /*                                                                        */
  27 /* FWP is free software; you can redistribute it and/or modify it         */
  28 /* under terms of the GNU General Public License as published by the      */
  29 /* Free Software Foundation; either version 2, or (at your option) any    */
  30 /* later version.  FWP is distributed in the hope that it will be         */
  31 /* useful, but WITHOUT ANY WARRANTY; without even the implied warranty    */
  32 /* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU    */
  33 /* General Public License for more details. You should have received a    */
  34 /* copy of the GNU General Public License along with FWP; see file        */
  35 /* COPYING. If not, write to the Free Software Foundation, 675 Mass Ave,  */
  36 /* Cambridge, MA 02139, USA.                                              */
  37 /*                                                                        */
  38 /* As a special exception, including FWP header files in a file,          */
  39 /* instantiating FWP generics or templates, or linking other files        */
  40 /* with FWP objects to produce an executable application, does not        */
  41 /* by itself cause the resulting executable application to be covered     */
  42 /* by the GNU General Public License. This exception does not             */
  43 /* however invalidate any other reasons why the executable file might be  */
  44 /* covered by the GNU Public License.                                     */
  45 /**************************************************************************/
  46 #include <fna.h>
  47 #include <fres_vres.h>
  48 #include <frsh_forb.h>
  49 #include "fwp_endpoint.h"
  50 #include "fwp_vres.h"
  51 #include "fwp.h"
  52 #include "fwp_res.h"
  53 #include "fwp_utils.h"
  54 #include "fwp_debug.h"
  55
  56 int fwp_fna_init(const frsh_resource_id_t resource_id)
  57 {
  58         int rv;
  59
  60         if ((rv = fwp_init()))
  61                 return rv;
  62
  63         return fra_fwp_init();
  64 }
  65
  66 int fwp_fna_network_budget_to_bytes(const frsh_resource_id_t resource_id,
  67                         const frsh_rel_time_t *budget, size_t *nbytes)
  68 {
  69         *nbytes = budget->tv_nsec;
  70         return 0;
  71 }
  72
  73 int fwp_fna_network_bytes_to_budget(const frsh_resource_id_t resource_id,
  74                         const size_t nbytes, frsh_rel_time_t *budget)
  75 {
  76         budget->tv_nsec = nbytes;
  77         budget->tv_sec = 0;
  78         return 0;
  79 }
  80
  81 int fwp_fna_send_endpoint_created(fna_endpoint_data_t  *endpoint)
  82 {
  83         unsigned int node, port;
  84         fwp_endpoint_attr_t *attr;
  85         struct fwp_endpoint *fwp_epoint;
  86         int rv;
  87         frsh_send_endpoint_protocol_info_t *spi;
  88
  89         node = (unsigned int) endpoint->destination;
  90         port = (unsigned int) endpoint->stream_id;
  91         attr = NULL;
  92
  93         spi = &endpoint->endpoint_protocol_info.send;
  94         if (spi->size == sizeof(fwp_endpoint_attr_t))
  95                 attr = (fwp_endpoint_attr_t*)spi->body;
  96         rv = fwp_send_endpoint_create(node, port, attr, &fwp_epoint);
  97         endpoint->protocol_info.body = fwp_epoint;
  98         return rv;
  99 }
 100
 101 int fwp_fna_receive_endpoint_created(fna_endpoint_data_t  *endpoint)
 102 {
 103         unsigned int node,port;
 104         fwp_endpoint_attr_t *attr;
 105         struct fwp_endpoint *fwp_epoint;
 106         int rv;
 107
 108         node = (unsigned int) endpoint->destination;
 109         port = (unsigned int) endpoint->stream_id;
 110         attr = (fwp_endpoint_attr_t*) endpoint->protocol_info.body;
 111         rv = fwp_receive_endpoint_create(port, attr, &fwp_epoint);
 112         if (rv)
 113                 return rv;
 114
 115         endpoint->protocol_info.body = fwp_epoint;
 116         fwp_endpoint_get_params(fwp_epoint, &node, &port, attr);
 117         endpoint->stream_id = port;
 118         FWP_DEBUG("PORT= %d\n", port);
 119
 120         return 0;
 121 }
 122
 123 int fwp_fna_send_endpoint_bind(fna_endpoint_data_t *endpoint, fna_vres_id_t vres)
 124 {
 125         return fwp_send_endpoint_bind(endpoint->protocol_info.body,
 126                                         (struct fwp_vres *) vres->priv);
 127 }
 128
 129 int fwp_fna_send_endpoint_unbind(fna_endpoint_data_t *endpoint)
 130 {
 131         return fwp_send_endpoint_unbind(endpoint->protocol_info.body);
 132 }
 133
 134 int fwp_fna_endpoint_destroy(fna_endpoint_data_t  *endpoint)
 135 {
 136         return fwp_endpoint_destroy(endpoint->endpoint_protocol_info.send.body);
 137 }
 138
 139 /** FNA send routine */
 140 int fwp_fna_send_sync(const fna_endpoint_data_t *endpoint, const void *msg,
 141                         const size_t size)
 142 {
 143         struct fwp_endpoint *fwp_epoint;
 144
 145         fwp_epoint = endpoint->protocol_info.body;
 146         return fwp_send_sync(fwp_epoint, msg, size);
 147 }
 148
 149 int fwp_fna_send_async(const fna_endpoint_data_t *endpoint,const void *msg,
 150                    const size_t size)
 151 {
 152         struct fwp_endpoint *fwp_epoint;
 153
 154         fwp_epoint = (struct fwp_endpoint*) endpoint->protocol_info.body;
 155         return fwp_send_async(fwp_epoint, msg, size);
 156 }
 157
 158 /** FNA receive routines */
 159 int fwp_fna_receive(const fna_endpoint_data_t *endpoint,
 160                         void *buffer, const size_t buffer_size,
 161                         size_t *received_bytes, frsh_network_address_t *from)
 162 {
 163         unsigned int from_addr;
 164         ssize_t len;
 165         struct fwp_endpoint *fwp_epoint;
 166         int flags = 0;
 167
 168         fwp_epoint = (struct fwp_endpoint*) endpoint->protocol_info.body;
 169         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 170         if (len < 0)
 171                 return len;
 172
 173         *received_bytes = len;
 174         *from = from_addr;
 175
 176         return 0;
 177 }
 178
 179 int fwp_fna_receive_sync(const fna_endpoint_data_t *endpoint, void *buffer,
 180                          const size_t buffer_size, size_t *received_bytes,
 181                          frsh_network_address_t *from)
 182 {
 183         unsigned int from_addr;
 184         ssize_t len;
 185         struct fwp_endpoint *fwp_epoint;
 186         int flags = 0;
 187
 188         fwp_epoint = (struct fwp_endpoint*) endpoint->protocol_info.body;
 189         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 190         if (len < 0)
 191                 return len;
 192
 193         if (received_bytes)
 194                 *received_bytes = len;
 195         if (from)
 196                 *from = from_addr;
 197
 198         return 0;
 199 }
 200
 201 int fwp_fna_receive_async(const fna_endpoint_data_t *endpoint, void *buffer,
 202                          const size_t buffer_size, size_t *received_bytes,
 203                          frsh_network_address_t *from)
 204 {
 205         unsigned int from_addr;
 206         ssize_t len;
 207         struct fwp_endpoint *fwp_epoint;
 208         int flags = 0;
 209
 210         fwp_epoint = (struct fwp_endpoint*) endpoint->protocol_info.body;
 211         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 212         if (len < 0)
 213                 return len;
 214
 215         if (received_bytes)
 216                 *received_bytes = len;
 217         if (from)
 218                 *from = from_addr;
 219
 220         return 0;
 221 }
 222
 223 int fwp_fna_vres_destroy(const frsh_resource_id_t resource_id,
 224                      const fna_vres_id_t vres)
 225 {
 226 //      return fwp_vres_close(vres);
 227         return 0;
 228 }
 229
 230 fna_operations_t fwp_fna_operations = {
 231     .fna_init = fwp_fna_init,
 232     .fna_contract_negotiate = NULL,
 233     .fna_contract_renegotiate_sync = NULL,
 234     .fna_contract_renegotiate_async = NULL,
 235     .fna_vres_get_renegotiation_status = NULL,
 236     .fna_vres_destroy = fwp_fna_vres_destroy,
 237     .fna_vres_get_contract = NULL,
 238     .fna_vres_get_usage = NULL,
 239     .fna_vres_get_remaining_budget = NULL,
 240     .fna_vres_get_budget_and_period = NULL,
 241     .fna_resource_get_capacity = NULL,
 242     .fna_resource_get_total_weight = NULL,
 243     .fna_vres_decrease_capacity = NULL,
 244     .fna_send_sync = fwp_fna_send_sync,
 245     .fna_send_async = fwp_fna_send_async,
 246     .fna_receive_sync = fwp_fna_receive_sync,
 247     .fna_receive_async = fwp_fna_receive_async,
 248     .fna_send_endpoint_get_status = NULL,
 249     .fna_endpoint_destroy = fwp_fna_endpoint_destroy,
 250     .fna_send_endpoint_created = fwp_fna_send_endpoint_created,
 251     .fna_send_endpoint_bind = fwp_fna_send_endpoint_bind,
 252     .fna_send_endpoint_unbind = fwp_fna_send_endpoint_unbind,
 253     .fna_receive_endpoint_created = fwp_fna_receive_endpoint_created,
 254     .fna_receive_endpoint_get_status = NULL,
 255     .fna_network_get_max_message_size = NULL,
 256     .fna_network_bytes_to_budget = fwp_fna_network_bytes_to_budget,
 257     .fna_network_budget_to_bytes = fwp_fna_network_budget_to_bytes,
 258     .fna_network_get_min_eff_budget = NULL
 259 };
 260