fwp/mngr/fwp_mngr.c

   1 //#include "admtest.h"
   2 #include "fwp_mngt.h"
   3 #include "fwp_contract_table.h"
   4 #include "fwp_agent_table.h"
   5 #include "fwp_admctrl.h"
   6
   7 //static struct sockaddr_un fwp_laddr;          /**< FWP local address */
   8 static struct sockaddr_in fwp_raddr;            /**< FWP remote address */
   9 static int    fwp_lsockfd;                      /**< FWP local sockfd */
  10 static int    fwp_rsockfd;                      /**< FWP remote sockfd */
  11 static fd_set fwp_input_fdset;
  12
  13 /* buffer and socket for incomming message */
  14 static unsigned char    buffer[FWP_MTU];
  15 struct fwp_sockaddr     peer;
  16
  17 /* service vres */
  18 fwp_vres_d_t            service_vresd;  /**< service vres decriptor */
  19
  20 /* List of requested contracts */
  21 /*fwp_contractlist_t    contractlist_req;*/
  22 /* for simplicity only one contract is to be negotiated now*/
  23 fwp_contract_data_t     *contract_req;
  24
  25 /* Admission control test */
  26 fwp_admctrl_test_t fwp_admctrl_test = &fwp_admctrl_stupid;
  27
  28 /**
  29  * fwp_agent_init
  30  *
  31  * FWP agent inicialization
  32  * - opens unix socket for local communication
  33  * - opens udp socket for remote comunication
  34  *
  35  *  @fwp_mnr_addr_s string that contains the address of AP where
  36  *  where fwp manager is located
  37  *
  38  */
  39 int fwp_mngr_init()
  40 {
  41         fwpmngr_info = my_info;
  42
  43         FWP_DEBUG("Management receive endpoint created\n");
  44         fwp_receive_endpoint_create(FWP_APP_MNGT_PORT, 0, &mngt_repointd);
  45         my_info.port = FWP_APP_MNGT_PORT;
  46
  47
  48
  49         return 0;
  50 }
  51
  52 /**
  53  * fwp_mngt_input
  54  *
  55  * Function waits for remote or local message
  56  *
  57  * @msgb  received message
  58  * \return
  59  * On success, it returns 0 and the pointer to received message in msgb parameter.
  60  * On error, it returns negative error code
  61  *
  62  */
  63 int fwp_mngr_input(struct fwp_msgb **pmsgb)
  64 {
  65         struct fwp_msgb *msgb;
  66         struct sockaddr_in *peer_in;
  67         int len, size;
  68         fd_set fdset;
  69
  70         memcpy(&fdset, &fwp_input_fdset, sizeof(fd_set));
  71         FWP_DEBUG("Waiting for messages\n");
  72
  73         if (select(getdtablesize()+1, &fdset, (fd_set *)0,
  74                    (fd_set *)0, NULL) < 0){
  75
  76                 perror("Error in select");
  77                 return (-errno);
  78         }
  79
  80         if (FD_ISSET(fwp_lsockfd, &fdset)){
  81                 FWP_DEBUG("Management message received from local socket\n");
  82                 _fwp_recvfrom(len, fwp_lsockfd, buffer, FWP_MTU, 0,
  83                                 peer.addr, &peer.addrlen);
  84                 size = 0;
  85         }
  86         else {
  87                 FWP_DEBUG("Management message received from remote socket\n");
  88                 _fwp_recvfrom(len, fwp_rsockfd, buffer, FWP_MTU, 0,
  89                                 peer.addr, &peer.addrlen);
  90
  91                 /* we have to set UDP port fwp agent is listening on for
  92                  * responses from AP
  93                  * */
  94                 peer_in = (struct sockaddr_in*) peer.addr;
  95                 peer_in->sin_port = htons(FWP_AGENT_UDP_PORT);
  96                 size = sizeof(struct fwp_sockaddr);
  97         }
  98
  99         FWP_DEBUG("Creating fwp msgb len=%d\n",len);
 100         /* For future: fwp_socket could be allocated behind data in msgb*/
 101         if (!(msgb = fwp_msgb_alloc(size))) {
 102                 perror("No memory available.\n");
 103                 return -ENOMEM;
 104         }
 105         /*memcpy(fwp_msgb_put(msgb, len), buffer, len); */
 106         msgb->data = buffer;
 107         fwp_msgb_put(msgb, len);
 108         msgb->peer = &peer;
 109
 110         *pmsgb = msgb;
 111         return (0);
 112 }
 113
 114 int
 115 fwp_mngr_contract_negt_response(fwp_contract_data_t *contdata)
 116 {
 117         struct fwp_msgb         *msgb;
 118
 119         if (!(msgb = fwp_msgb_alloc(sizeof(struct fwp_msg_header) +
 120                                     sizeof(struct fwp_msg_vres_params)))) {
 121
 122                 fprintf(stderr, "No memory available.\n");
 123                 return -ENOMEM;
 124         }
 125
 126         fwp_msg_header_deflate(msgb->tail, FWP_CONTNEGT_RES,
 127                                 &contdata->contract_call_id);
 128         fwp_msgb_put(msgb, sizeof(struct fwp_msg_header));
 129         fwp_msg_vres_params_deflate(msgb->tail, contdata->status,
 130                                     &contdata->vres_params);
 131         fwp_msgb_put(msgb, sizeof(struct fwp_msg_vres_params));
 132
 133         msgb->peer = &contdata->agent->addr;
 134         /* TODO: add sending to local app through unix socket */
 135         _fwp_vres_send(service_vresd, msgb);
 136         return 0;
 137 }
 138
 139 static int fwp_mngr_contract_accept(fwp_contract_data_t *contdata)
 140 {
 141         fwp_agent_data_t *agdata;
 142
 143         if (contdata->status != FWP_CONT_NEGOTIATED) {
 144                 return -1;
 145         }
 146
 147         agdata = contdata->agent;
 148         if (agdata) {
 149                 fwp_contract_table_insert(&agdata->contract_table, contdata);
 150         }
 151         return 0;
 152 }
 153
 154 int fwp_mngr_contract_negt_request(fwp_msgb_t *msgb, fwp_appcall_id_t *appcall_id,
 155                                         fwp_contract_data_t **contract_data)
 156 {
 157         fwp_contract_t          contract;
 158         fwp_contract_data_t     *contdata;
 159
 160         /* deserialize contract from message */
 161         fwp_msg_contract_inflate(msgb->data, &contract);
 162         fwp_msgb_pull(msgb, sizeof(struct fwp_msg_contract));
 163
 164         /* prepare contract data structure */
 165         contdata = (fwp_contract_data_t*) malloc(sizeof(fwp_contract_data_t));
 166         /* copy contract to contract_data */
 167         memcpy(&contdata->contract, &contract, sizeof(contdata->contract));
 168         /* set pointer to agent data */
 169         contdata->agent = fwp_agent_table_find(msgb->peer);
 170         /* set appid and hid */
 171         contdata->contract_call_id = *appcall_id;
 172         contdata->status = FWP_CONT_REQUESTED;
 173
 174         fwp_msgb_free(msgb);
 175
 176         /* put contract data into contract requested list */
 177         /*fwp_contractlist_insert(&contractlist_req, contdata);*/
 178         *contract_data = contdata;
 179
 180         return 0;
 181 }
 182
 183 static void fwp_mngr_msg_handler(struct fwp_msgb *msgb)
 184 {
 185         unsigned int code;
 186         fwp_appcall_id_t appcall_id;
 187
 188         fwp_msg_header_inflate(msgb->data, &code, &appcall_id);
 189         fwp_msgb_pull(msgb, sizeof(struct fwp_msg_header));
 190         FWP_DEBUG("code = %d , appid = %d callid = %d\n", code,
 191                         appcall_id.appid, appcall_id.callid);
 192
 193         fwp_agent_table_insert(msgb->peer);
 194
 195         switch (code) {
 196                 case  FWP_CONTNEGT_REQ:
 197                         FWP_DEBUG("Negotiation Request received\n");
 198                         fwp_mngr_contract_negt_request(msgb, &appcall_id,
 199                                                         &contract_req);
 200                         FWP_DEBUG("Executing admission control test\n");
 201                         fwp_admctrl_test(contract_req);
 202
 203                         /* right now simply add to contract table if negotiated */
 204                         //fwp_mngr_contract_accept(&msgb->peer, contract_req);
 205
 206                         FWP_DEBUG("Preparing NEGT_RES msg\n");
 207                         fwp_mngr_contract_negt_response(contract_req);
 208                         break;
 209                 default:
 210                         printf("Invalid message\n.");
 211                         fwp_msgb_free(msgb);
 212         }
 213 }
 214
 215 void fwp_mngr()
 216 {
 217         struct fwp_msgb *msgb;
 218
 219         /* start admission control thread */
 220         while (1 /*exit_flag*/){
 221                 fwp_mngr_input(&msgb);
 222                 if (msgb)
 223                         fwp_mngr_msg_handler(msgb);
 224                 FWP_DEBUG("Mngr prepared to wait for next msg.\n");
 225         }
 226 }
 227
 228 int main()
 229 {
 230         if (fwp_init() < 0) {
 231                 fprintf(stderr,"FWP initialization failed.\n");
 232                 exit(1);
 233
 234         }
 235
 236         if (fwp_mngr_init() < 0) {
 237                 fprintf(stderr,"FWP manager initialization failed.\n");
 238                 exit(1);
 239
 240         }
 241
 242         /* execute agent function */
 243         fwp_mngr();
 244
 245         return 0;
 246 }