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         fwp_endpoint_t *fwp_epoint;
  86         int rv;
  87
  88         node = (unsigned int) endpoint->destination;
  89         port = (unsigned int) endpoint->stream_id;
  90         attr = (fwp_endpoint_attr_t*) endpoint->endpoint_protocol_info.send.body;
  91         rv = fwp_send_endpoint_create(node, port, attr, &fwp_epoint);
  92         endpoint->protocol_info.body = fwp_epoint;
  93         return rv;
  94 }
  95
  96 int fwp_fna_receive_endpoint_created(fna_endpoint_data_t  *endpoint)
  97 {
  98         unsigned int node,port;
  99         fwp_endpoint_attr_t *attr;
 100         fwp_endpoint_t *fwp_epoint;
 101         int rv;
 102
 103         node = (unsigned int) endpoint->destination;
 104         port = (unsigned int) endpoint->stream_id;
 105         attr = (fwp_endpoint_attr_t*) endpoint->protocol_info.body;
 106         rv = fwp_receive_endpoint_create(port, attr, &fwp_epoint);
 107         if (rv)
 108                 return rv;
 109
 110         endpoint->protocol_info.body = fwp_epoint;
 111         fwp_endpoint_get_params(fwp_epoint, &node, &port, attr);
 112         endpoint->stream_id = port;
 113         FWP_DEBUG("PORT= %d\n", port);
 114
 115         return 0;
 116 }
 117
 118 int fwp_fna_send_endpoint_bind(fna_endpoint_data_t *endpoint, fna_vres_id_t vres)
 119 {
 120         return fwp_send_endpoint_bind(endpoint->protocol_info.body,
 121                                         (fwp_vres_d_t) vres->priv);
 122 }
 123
 124 int fwp_fna_send_endpoint_unbind(fna_endpoint_data_t *endpoint)
 125 {
 126         return fwp_send_endpoint_unbind(endpoint->protocol_info.body);
 127 }
 128
 129 int fwp_fna_endpoint_destroy(fna_endpoint_data_t  *endpoint)
 130 {
 131         return fwp_endpoint_destroy(endpoint->endpoint_protocol_info.send.body);
 132 }
 133
 134 /** FNA send routine */
 135 int fwp_fna_send(const fna_endpoint_data_t *endpoint, const void *msg,
 136                         const size_t size)
 137 {
 138         fwp_endpoint_t *fwp_epoint;
 139         int flags = 0;
 140
 141         fwp_epoint = endpoint->protocol_info.body;
 142         return fwp_send(fwp_epoint, msg, size, flags);
 143 }
 144
 145 int fwp_fna_send_sync(const fna_endpoint_data_t *endpoint, const void *msg,
 146                         const size_t size)
 147 {
 148         fwp_endpoint_t *fwp_epoint;
 149         int flags = 0;
 150
 151         fwp_epoint = endpoint->protocol_info.body;
 152         return fwp_send(fwp_epoint, msg, size, flags);
 153 }
 154
 155 int fwp_fna_send_async(const fna_endpoint_data_t *endpoint,const void *msg,
 156                    const size_t size)
 157 {
 158         fwp_endpoint_t *fwp_epoint;
 159
 160         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 161         return fwp_send(fwp_epoint, msg, size, MSG_DONTWAIT);
 162 }
 163
 164 /** FNA receive routines */
 165 int fwp_fna_receive(const fna_endpoint_data_t *endpoint,
 166                         void *buffer, const size_t buffer_size,
 167                         size_t *received_bytes, frsh_network_address_t *from)
 168 {
 169         unsigned int from_addr;
 170         ssize_t len;
 171         fwp_endpoint_t *fwp_epoint;
 172         int flags = 0;
 173
 174         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 175         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 176         if (len < 0)
 177                 return len;
 178
 179         *received_bytes = len;
 180         *from = from_addr;
 181
 182         return 0;
 183 }
 184
 185 int fwp_fna_receive_sync(const fna_endpoint_data_t *endpoint, void *buffer,
 186                          const size_t buffer_size, size_t *received_bytes,
 187                          frsh_network_address_t *from)
 188 {
 189         unsigned int from_addr;
 190         ssize_t len;
 191         fwp_endpoint_t *fwp_epoint;
 192         int flags = 0;
 193
 194         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 195         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 196         if (len < 0)
 197                 return len;
 198
 199         if (received_bytes)
 200                 *received_bytes = len;
 201         if (from)
 202                 *from = from_addr;
 203
 204         return 0;
 205 }
 206
 207 int fwp_fna_receive_async(const fna_endpoint_data_t *endpoint, void *buffer,
 208                          const size_t buffer_size, size_t *received_bytes,
 209                          frsh_network_address_t *from)
 210 {
 211         unsigned int from_addr;
 212         ssize_t len;
 213         fwp_endpoint_t *fwp_epoint;
 214         int flags = 0;
 215
 216         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 217         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 218         if (len < 0)
 219                 return len;
 220
 221         if (received_bytes)
 222                 *received_bytes = len;
 223         if (from)
 224                 *from = from_addr;
 225
 226         return 0;
 227 }
 228
 229 int fwp_fna_vres_destroy(const frsh_resource_id_t resource_id,
 230                      const fna_vres_id_t vres)
 231 {
 232 //      return fwp_vres_close(vres);
 233         return 0;
 234 }
 235
 236 fna_operations_t fwp_fna_operations = {
 237     .fna_init = fwp_fna_init,
 238     .fna_contract_negotiate = NULL,
 239     .fna_contract_renegotiate_sync = NULL,
 240     .fna_contract_renegotiate_async = NULL,
 241     .fna_vres_get_renegotiation_status = NULL,
 242     .fna_vres_destroy = fwp_fna_vres_destroy,
 243     .fna_vres_get_contract = NULL,
 244     .fna_vres_get_usage = NULL,
 245     .fna_vres_get_remaining_budget = NULL,
 246     .fna_vres_get_budget_and_period = NULL,
 247     .fna_resource_get_capacity = NULL,
 248     .fna_resource_get_total_weight = NULL,
 249     .fna_vres_decrease_capacity = NULL,
 250     .fna_send_sync = NULL,
 251     .fna_send_async = fwp_fna_send_async,
 252     .fna_receive_sync = fwp_fna_receive_sync,
 253     .fna_receive_async = fwp_fna_receive_async,
 254     .fna_send_endpoint_get_status = NULL,
 255     .fna_endpoint_destroy = fwp_fna_endpoint_destroy,
 256     .fna_send_endpoint_created = fwp_fna_send_endpoint_created,
 257     .fna_send_endpoint_bind = fwp_fna_send_endpoint_bind,
 258     .fna_send_endpoint_unbind = fwp_fna_send_endpoint_unbind,
 259     .fna_receive_endpoint_created = fwp_fna_receive_endpoint_created,
 260     .fna_receive_endpoint_get_status = NULL,
 261     .fna_network_get_max_message_size = NULL,
 262     .fna_network_bytes_to_budget = fwp_fna_network_bytes_to_budget,
 263     .fna_network_budget_to_bytes = fwp_fna_network_budget_to_bytes,
 264     .fna_network_get_min_eff_budget = NULL
 265 };
 266