fwp/lib/frsh_fwp/fwp_fna.c

   1 #include <fna.h>
   2 #include <fres_vres.h>
   3 #include <frsh_forb.h>
   4 #include "fwp_endpoint.h"
   5 #include "fwp_vres.h"
   6 #include "fwp.h"
   7 #include "fwp_res.h"
   8
   9 int fwp_fna_init(const frsh_resource_id_t resource_id)
  10 {
  11         int rv;
  12
  13         if ((rv = fwp_init()))
  14                 return rv;
  15
  16         return fra_fwp_init(frsh_forb_global.orb, frsh_forb_global.fcb,
  17                                 &frsh_forb_global.alloc_executor);
  18 }
  19
  20 int fwp_fna_network_budget_to_bytes(const frsh_resource_id_t resource_id,
  21                         const frsh_rel_time_t *budget, size_t *nbytes)
  22 {
  23         *nbytes = budget->tv_nsec;
  24         return 0;
  25 }
  26
  27 int fwp_fna_network_bytes_to_budget(const frsh_resource_id_t resource_id,
  28                         const size_t nbytes, frsh_rel_time_t *budget)
  29 {
  30         budget->tv_nsec = nbytes;
  31         budget->tv_sec = 0;
  32         return 0;
  33 }
  34
  35 int fwp_fna_send_endpoint_created(fna_endpoint_data_t  *endpoint)
  36 {
  37         unsigned int node, port;
  38         fwp_endpoint_attr_t *attr;
  39         fwp_endpoint_t *fwp_epoint;
  40         int rv;
  41
  42         node = (unsigned int) endpoint->destination;
  43         port = (unsigned int) endpoint->stream_id;
  44         attr = (fwp_endpoint_attr_t*) endpoint->endpoint_protocol_info.send.body;
  45         rv = fwp_send_endpoint_create(node, port, attr, &fwp_epoint);
  46         if (rv)
  47                 return rv;
  48         endpoint->protocol_info.body = fwp_epoint;
  49         return 0;
  50 }
  51
  52 int fwp_fna_receive_endpoint_created(fna_endpoint_data_t  *endpoint)
  53 {
  54         unsigned int node,port;
  55         fwp_endpoint_attr_t *attr;
  56         fwp_endpoint_t *fwp_epoint;
  57         int rv;
  58
  59         node = (unsigned int) endpoint->destination;
  60         port = (unsigned int) endpoint->stream_id;
  61         attr = (fwp_endpoint_attr_t*) endpoint->protocol_info.body;
  62         rv = fwp_receive_endpoint_create(port, attr, &fwp_epoint);
  63         if (rv)
  64                 return rv;
  65
  66         endpoint->protocol_info.body = fwp_epoint;
  67         fwp_endpoint_get_params(fwp_epoint, &node, &port, attr);
  68         endpoint->stream_id = port;
  69
  70         return 0;
  71 }
  72
  73 int fwp_fna_send_endpoint_bind(fna_endpoint_data_t *endpoint, fna_vres_id_t vres)
  74 {
  75         return fwp_send_endpoint_bind(endpoint->protocol_info.body,
  76                                         (fwp_vres_d_t) vres->priv);
  77 }
  78
  79 int fwp_fna_send_endpoint_unbind(fna_endpoint_data_t *endpoint)
  80 {
  81         return fwp_send_endpoint_unbind(endpoint->protocol_info.body);
  82 }
  83
  84 int fwp_fna_endpoint_destroy(fna_endpoint_data_t  *endpoint)
  85 {
  86         return fwp_endpoint_destroy(endpoint->endpoint_protocol_info.send.body);
  87 }
  88
  89 /** FNA send routine */
  90 int fwp_fna_send(const fna_endpoint_data_t *endpoint, const void *msg,
  91                         const size_t size)
  92 {
  93         fwp_endpoint_t *fwp_epoint;
  94         int flags = 0;
  95
  96         fwp_epoint = endpoint->protocol_info.body;
  97         return fwp_send(fwp_epoint, msg, size, flags);
  98 }
  99
 100 int fwp_fna_send_sync(const fna_endpoint_data_t *endpoint, const void *msg,
 101                         const size_t size)
 102 {
 103         fwp_endpoint_t *fwp_epoint;
 104         int flags = 0;
 105
 106         fwp_epoint = endpoint->protocol_info.body;
 107         return fwp_send(fwp_epoint, msg, size, flags);
 108 }
 109
 110 int fwp_fna_send_async(const fna_endpoint_data_t *endpoint,const void *msg,
 111                    const size_t size)
 112 {
 113         fwp_endpoint_t *fwp_epoint;
 114
 115         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 116         return fwp_send(fwp_epoint, msg, size, MSG_DONTWAIT);
 117 }
 118
 119 /** FNA receive routines */
 120 int fwp_fna_receive(const fna_endpoint_data_t *endpoint,
 121                         void *buffer, const size_t buffer_size,
 122                         size_t *received_bytes, frsh_network_address_t *from)
 123 {
 124         unsigned int from_addr;
 125         size_t len;
 126         fwp_endpoint_t *fwp_epoint;
 127         int flags = 0;
 128
 129         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 130         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 131         if (len < 0)
 132                 return len;
 133
 134         *received_bytes = len;
 135         *from = from_addr;
 136
 137         return 0;
 138 }
 139
 140 int fwp_fna_receive_sync(const fna_endpoint_data_t *endpoint, void *buffer,
 141                          const size_t buffer_size, size_t *received_bytes,
 142                          frsh_network_address_t *from)
 143 {
 144         unsigned int from_addr;
 145         size_t len;
 146         fwp_endpoint_t *fwp_epoint;
 147         int flags = 0;
 148
 149         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 150         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 151         if (len < 0)
 152                 return len;
 153
 154         *received_bytes = len;
 155         *from = from_addr;
 156
 157         return 0;
 158 }
 159
 160 int fwp_fna_receive_async(const fna_endpoint_data_t *endpoint, void *buffer,
 161                          const size_t buffer_size, size_t *received_bytes,
 162                          frsh_network_address_t *from)
 163 {
 164         unsigned int from_addr;
 165         size_t len;
 166         fwp_endpoint_t *fwp_epoint;
 167         int flags = 0;
 168
 169         fwp_epoint = (fwp_endpoint_t*) endpoint->protocol_info.body;
 170         len = fwp_recv(fwp_epoint, buffer, buffer_size, &from_addr, flags);
 171         if (len < 0)
 172                 return len;
 173
 174         *received_bytes = len;
 175         *from = from_addr;
 176
 177         return 0;
 178 }
 179
 180 int fwp_fna_vres_destroy(const frsh_resource_id_t resource_id,
 181                      const fna_vres_id_t vres)
 182 {
 183 //      return fwp_vres_close(vres);
 184         return 0;
 185 }
 186
 187 fna_operations_t fwp_fna_operations = {
 188     .fna_init = fwp_fna_init,
 189     .fna_contract_negotiate = NULL,
 190     .fna_contract_renegotiate_sync = NULL,
 191     .fna_contract_renegotiate_async = NULL,
 192     .fna_vres_get_renegotiation_status = NULL,
 193     .fna_vres_destroy = fwp_fna_vres_destroy,
 194     .fna_vres_get_contract = NULL,
 195     .fna_vres_get_usage = NULL,
 196     .fna_vres_get_remaining_budget = NULL,
 197     .fna_vres_get_budget_and_period = NULL,
 198     .fna_resource_get_capacity = NULL,
 199     .fna_resource_get_total_weight = NULL,
 200     .fna_vres_decrease_capacity = NULL,
 201     .fna_send_sync = NULL,
 202     .fna_send_async = fwp_fna_send_async,
 203     .fna_receive_sync = fwp_fna_receive_sync,
 204     .fna_receive_async = fwp_fna_receive_async,
 205     .fna_send_endpoint_get_status = NULL,
 206     .fna_endpoint_destroy = fwp_fna_endpoint_destroy,
 207     .fna_send_endpoint_created = fwp_fna_send_endpoint_created,
 208     .fna_send_endpoint_bind = fwp_fna_send_endpoint_bind,
 209     .fna_send_endpoint_unbind = fwp_fna_send_endpoint_unbind,
 210     .fna_receive_endpoint_created = fwp_fna_receive_endpoint_created,
 211     .fna_receive_endpoint_get_status = NULL,
 212     .fna_network_get_max_message_size = NULL,
 213     .fna_network_bytes_to_budget = fwp_fna_network_bytes_to_budget,
 214     .fna_network_budget_to_bytes = fwp_fna_network_budget_to_bytes,
 215     .fna_network_get_min_eff_budget = NULL
 216 };
 217