src/asp-coordination-protocol.c

   1 /*
   2  * Copyright (c) 2016 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*****************************************************************************
  18  * Standard headers
  19  *****************************************************************************/
  20
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <time.h>
  25 #include <arpa/inet.h>
  26
  27 /*****************************************************************************
  28  * System headers
  29  *****************************************************************************/
  30
  31 #include <glib.h>
  32 #include <gio/gio.h>
  33 /*#include <dlog.h> */
  34
  35 /*****************************************************************************
  36  * ASP coordination protocol header
  37  *****************************************************************************/
  38 #include "asp-coordination-protocol.h"
  39 #include "asp-session-peer.h"
  40 #include "asp-manager-util.h"
  41
  42 /*****************************************************************************
  43  * Macros and Typedefs
  44  *****************************************************************************/
  45 #define RW_BUF_SIZE 1600
  46 #define LENGTH_MAX 144
  47 #define ASP_COORDINATION_PROTOCOL_PORT 7235
  48
  49 /* TODO : define session data structure */
  50
  51 /*****************************************************************************
  52  * Global Variables
  53  *****************************************************************************/
  54 GSocket *coordination_protocol_socket = NULL;
  55 GSource *source = NULL;
  56
  57 /* TODO : define local memory for session data structure */
  58
  59 /*****************************************************************************
  60  * Local Functions Definition
  61  *****************************************************************************/
  62
  63 static gboolean asp_coordination_protocol_read_cb(GIOChannel *src,
  64                 GIOCondition condition, gpointer data);
  65 static void asp_coordination_protocol_ack_handler(GSocketAddress *sock_addr,
  66                 void *input_data);
  67 static void asp_coordination_protocol_nack_handler(GSocketAddress *sock_addr,
  68                 void *input_data);
  69 static void asp_coordination_protocol_version_handler(GSocketAddress *sock_addr,
  70                 void *input_data);
  71 static void asp_coordination_protocol_request_session_handler(
  72         GSocketAddress *sock_addr, void *input_data);
  73 static void asp_coordination_protocol_allowed_port_handler(
  74         GSocketAddress *sock_addr, void *input_data);
  75 static void asp_coordination_protocol_remove_session_handler(
  76         GSocketAddress *sock_addr, void *input_data);
  77
  78 static gboolean asp_coordination_protocol_send_ack(GSocketAddress *sock_addr,
  79                 asp_ack_s *input_data);
  80 static gboolean asp_coordination_protocol_send_nack(GSocketAddress *sock_addr,
  81                 asp_nack_s *input_data);
  82 static gboolean asp_coordination_protocol_send_version(GSocketAddress
  83                 *sock_addr, asp_version_s *input_data);
  84 static gboolean asp_coordination_protocol_send_added_session(
  85         GSocketAddress *sock_addr, asp_added_session_s *input_data);
  86 static gboolean asp_coordination_protocol_send_deferred_session(
  87         GSocketAddress  *sock_addr, asp_deferred_session_s *input_data);
  88 static gboolean asp_coordination_protocol_send_rejected_session(
  89         GSocketAddress  *sock_addr, asp_rejected_session_s *input_data);
  90 static gboolean asp_coordination_protocol_send_allowed_port(
  91         GSocketAddress *sock_addr, asp_allowed_port_s *input_data);
  92
  93 static gboolean asp_coordination_protocol_send_request_session(
  94         GSocketAddress *dest_addr, asp_request_session_s *input_data);
  95 static gboolean asp_coordination_protocol_send_remove_session(
  96         GSocketAddress *sock_addr, asp_remove_session_s *input_data);
  97 static void asp_coordination_protocol_added_session_handler(
  98         GSocketAddress *sock_addr, char *input_data);
  99 static void asp_coordination_protocol_rejected_session_handler(
 100         GSocketAddress *sock_addr, char *input_data);
 101 static void asp_coordination_protocol_deferred_session_handler(
 102         GSocketAddress *sock_addr, char *input_data);
 103
 104
 105 gboolean asp_coordination_protocol_init()
 106 {
 107         INFO_MSG;
 108
 109         GInetAddress *inet_addr = NULL;
 110         GSocketAddress *coordination_protocol_sockaddr = NULL;
 111         GError *error = NULL;
 112
 113         /* Create a udp socket as ipv4 */
 114         coordination_protocol_socket = g_socket_new(G_SOCKET_FAMILY_IPV4,
 115                                        G_SOCKET_TYPE_DATAGRAM, G_SOCKET_PROTOCOL_UDP, &error);
 116         g_assert_no_error(error);
 117
 118         inet_addr = g_inet_address_new_any(G_SOCKET_FAMILY_IPV4);
 119
 120         coordination_protocol_sockaddr = g_inet_socket_address_new(inet_addr,
 121                                          ASP_COORDINATION_PROTOCOL_PORT);
 122
 123         g_object_unref(inet_addr);
 124
 125         if (!g_socket_bind(coordination_protocol_socket, coordination_protocol_sockaddr,
 126                            TRUE, &error)) {
 127                 g_object_unref(coordination_protocol_socket);
 128                 return FALSE;
 129         }
 130         g_assert_no_error(error);
 131
 132         g_object_unref(coordination_protocol_sockaddr);
 133
 134         /* Get a source from socket */
 135         source = g_socket_create_source(coordination_protocol_socket, G_IO_IN, NULL);
 136
 137         /* Set a callback to be called when socket is readable */
 138         g_source_set_callback(source, (GSourceFunc) asp_coordination_protocol_read_cb,
 139                               coordination_protocol_socket, NULL);
 140
 141         g_source_attach(source, g_main_context_default());
 142
 143         g_source_unref(source);
 144         return TRUE;
 145 }
 146
 147 gboolean asp_coordination_protocol_destroy()
 148 {
 149         INFO_MSG;
 150
 151         GError *error = NULL;
 152         gboolean ret_val = FALSE;
 153         ret_val = g_socket_close(coordination_protocol_socket, &error);
 154         g_object_unref(coordination_protocol_socket);
 155         g_source_destroy(source);
 156         g_clear_error(&error);
 157
 158         return ret_val;
 159 }
 160
 161 gboolean asp_coordination_protocol_send_msg(GSocketAddress *input_sock_addr,
 162                 void *input_data)
 163 {
 164         INFO_MSG;
 165
 166         gboolean ret_val = FALSE;
 167
 168         asp_coord_header_s *asp_cord_header = (asp_coord_header_s *)input_data;
 169
 170         ASP_LOGD("%s asp_coordination_protocol_send_msg() asp_cord_header->opcode: %x",
 171                  ROLE, asp_cord_header->opcode);
 172
 173         switch (asp_cord_header->opcode) {
 174         case ASP_OPCODE_REQUEST_SESSION: {
 175                         ret_val = asp_coordination_protocol_send_request_session(input_sock_addr,
 176                                         (asp_request_session_s *)input_data);
 177                         break;
 178                 }
 179         case ASP_OPCODE_ADDED_SESSION: {
 180                         ret_val = asp_coordination_protocol_send_added_session(input_sock_addr,
 181                                         (asp_added_session_s *)input_data);
 182                         break;
 183                 }
 184         case ASP_OPCODE_REJECTED_SESSION: {
 185                         ret_val = asp_coordination_protocol_send_rejected_session(input_sock_addr,
 186                                         (asp_rejected_session_s *)input_data);
 187                         break;
 188                 }
 189         case ASP_OPCODE_REMOVE_SESSION: {
 190                         ret_val = asp_coordination_protocol_send_remove_session(input_sock_addr,
 191                                         (asp_remove_session_s *)input_data);
 192                         break;
 193                 }
 194         case ASP_OPCODE_ALLOWED_PORT: {
 195                         ret_val = asp_coordination_protocol_send_allowed_port(input_sock_addr,
 196                                         (asp_allowed_port_s *)input_data);
 197                         break;
 198                 }
 199         case ASP_OPCODE_VERSION: {
 200                         ret_val = asp_coordination_protocol_send_version(input_sock_addr,
 201                                         (asp_version_s *)input_data);
 202                         break;
 203                 }
 204         case ASP_OPCODE_DEFERRED_SESSION: {
 205                         ret_val = asp_coordination_protocol_send_deferred_session(input_sock_addr,
 206                                         (asp_deferred_session_s *)input_data);
 207                         break;
 208                 }
 209         case ASP_OPCODE_ACK: {
 210                         ret_val = asp_coordination_protocol_send_ack(input_sock_addr,
 211                                         (asp_ack_s *)input_data);
 212                         break;
 213                 }
 214         case ASP_OPCODE_NACK: {
 215                         ret_val = asp_coordination_protocol_send_nack(input_sock_addr,
 216                                         (asp_nack_s *)input_data);
 217                         break;
 218                 }
 219         default: {
 220                         break;
 221                 }
 222         }
 223         return ret_val;
 224 }
 225
 226 static gboolean asp_coordination_protocol_read_cb(GIOChannel *src,
 227                 GIOCondition condition, gpointer data)
 228 {
 229         INFO_MSG;
 230
 231         GSocket *read_sock = (GSocket *) data;
 232         GSocketAddress *read_sock_addr = NULL;
 233         static gchar read_buf[RW_BUF_SIZE];
 234         GError *error = NULL;
 235
 236         g_socket_receive_from(read_sock, &read_sock_addr, read_buf, RW_BUF_SIZE, NULL,
 237                               &error);
 238
 239         ASP_LOGD("%s commnad %x, %x", ROLE, (guint8) read_buf[0], (guint8) read_buf[1]);
 240
 241         switch ((guint8) read_buf[0]) {
 242         case ASP_OPCODE_REQUEST_SESSION: {
 243                         asp_coordination_protocol_request_session_handler(read_sock_addr, read_buf);
 244                         break;
 245                 }
 246         case ASP_OPCODE_ADDED_SESSION: {
 247                         asp_coordination_protocol_added_session_handler(read_sock_addr, read_buf);
 248                         break;
 249                 }
 250         case ASP_OPCODE_REJECTED_SESSION: {
 251                         asp_coordination_protocol_rejected_session_handler(read_sock_addr, read_buf);
 252                         break;
 253                 }
 254         case ASP_OPCODE_REMOVE_SESSION: {
 255                         asp_coordination_protocol_remove_session_handler(read_sock_addr, read_buf);
 256                         break;
 257                 }
 258         case ASP_OPCODE_ALLOWED_PORT: {
 259                         asp_coordination_protocol_allowed_port_handler(read_sock_addr, read_buf);
 260                         break;
 261                 }
 262         case ASP_OPCODE_VERSION: {
 263                         asp_coordination_protocol_version_handler(read_sock_addr, read_buf);
 264                         break;
 265                 }
 266         case ASP_OPCODE_DEFERRED_SESSION: {
 267                         asp_coordination_protocol_deferred_session_handler(read_sock_addr, read_buf);
 268                         break;
 269                 }
 270         case ASP_OPCODE_ACK: {
 271                         asp_coordination_protocol_ack_handler(read_sock_addr, read_buf);
 272                         break;
 273                 }
 274         case ASP_OPCODE_NACK: {
 275                         asp_coordination_protocol_nack_handler(read_sock_addr, read_buf);
 276                         break;
 277                 }
 278         default: {                                      /* Reserved msg or Error */
 279                         ASP_LOGD("%s error case:%x", ROLE, read_buf[0]);
 280                         break;
 281                 }
 282
 283         }
 284
 285         g_object_unref(read_sock_addr);
 286         g_clear_error(&error);
 287
 288         return TRUE;
 289 }
 290
 291 static void asp_coordination_protocol_ack_handler(GSocketAddress *sock_addr,
 292                 void *input_data)
 293 {
 294         INFO_MSG;
 295
 296         asp_ack_s *ack_data = (asp_ack_s *)input_data;
 297         asp_sess_peer_recv_msg(sock_addr, ack_data);
 298 }
 299
 300 static void asp_coordination_protocol_nack_handler(GSocketAddress *sock_addr,
 301                 void *input_data)
 302 {
 303         INFO_MSG;
 304
 305         asp_nack_s *nack_data = (asp_nack_s *)input_data;
 306         asp_sess_peer_recv_msg(sock_addr, nack_data);
 307 }
 308
 309 static void asp_coordination_protocol_version_handler(GSocketAddress *sock_addr,
 310                 void *input_data)
 311 {
 312         INFO_MSG;
 313
 314         asp_version_s *ver = (asp_version_s *)input_data;
 315         asp_sess_peer_recv_msg(sock_addr, ver);
 316 }
 317
 318 static void asp_coordination_protocol_request_session_handler(
 319         GSocketAddress *sock_addr, void *input_data)
 320 {
 321         INFO_MSG;
 322
 323         asp_request_session_s *request_sess = (asp_request_session_s *)input_data;
 324         request_sess->session_id = ntohl(request_sess->session_id);
 325         request_sess->advertisement_id = ntohl(request_sess->advertisement_id);
 326         asp_sess_peer_recv_msg(sock_addr, request_sess);
 327 }
 328
 329 static void asp_coordination_protocol_allowed_port_handler(
 330         GSocketAddress *sock_addr, void *input_data)
 331 {
 332         INFO_MSG;
 333
 334         asp_allowed_port_s *allowed_port_data = (asp_allowed_port_s *)input_data;
 335         allowed_port_data->session_id = ntohl(allowed_port_data->session_id);
 336         asp_sess_peer_recv_msg(sock_addr, allowed_port_data);
 337 }
 338
 339 static void asp_coordination_protocol_remove_session_handler(
 340         GSocketAddress *sock_addr, void *input_data)
 341 {
 342         INFO_MSG;
 343
 344         asp_remove_session_s *remove_sess = (asp_remove_session_s *)input_data;
 345         remove_sess->session_id = ntohl(remove_sess->session_id);
 346         asp_sess_peer_recv_msg(sock_addr, remove_sess);
 347 }
 348
 349 static gboolean asp_coordination_protocol_send_ack(GSocketAddress *sock_addr,
 350                 asp_ack_s *input_data)
 351 {
 352         INFO_MSG;
 353
 354         GError *error = NULL;
 355         asp_ack_s *send_ack = input_data;
 356
 357         g_socket_send_to(coordination_protocol_socket, sock_addr, (char *)send_ack,
 358                          sizeof(asp_ack_s), NULL, &error);
 359
 360         return TRUE;
 361 }
 362
 363 static gboolean asp_coordination_protocol_send_nack(GSocketAddress *sock_addr,
 364                 asp_nack_s *input_data)
 365 {
 366         INFO_MSG;
 367
 368         GError *error = NULL;
 369         asp_nack_s *send_nack = input_data;
 370
 371         g_socket_send_to(coordination_protocol_socket, sock_addr, (char *)send_nack,
 372                          sizeof(asp_nack_s), NULL, &error);
 373
 374         return TRUE;
 375 }
 376
 377 static gboolean asp_coordination_protocol_send_version(GSocketAddress
 378                 *sock_addr, asp_version_s *input_data)
 379 {
 380         INFO_MSG;
 381
 382         GError *error = NULL;
 383         asp_version_s *send_version = input_data;
 384
 385         g_socket_send_to(coordination_protocol_socket, sock_addr, (char *)send_version,
 386                          sizeof(asp_version_s), NULL, &error);
 387
 388         return TRUE;
 389 }
 390
 391 static gboolean asp_coordination_protocol_send_added_session(
 392         GSocketAddress *sock_addr, asp_added_session_s *input_data)
 393 {
 394         INFO_MSG;
 395
 396         GError *error = NULL;
 397         asp_added_session_s added_sess;
 398         memcpy(&added_sess, input_data, sizeof(asp_added_session_s));
 399         added_sess.session_id = htonl(added_sess.session_id);
 400
 401         g_socket_send_to(coordination_protocol_socket, sock_addr, (char *)&added_sess,
 402                          sizeof(asp_added_session_s), NULL, &error);
 403
 404         return TRUE;
 405 }
 406
 407 static gboolean asp_coordination_protocol_send_deferred_session(
 408         GSocketAddress *sock_addr, asp_deferred_session_s *input_data)
 409 {
 410         INFO_MSG;
 411
 412         GError *error = NULL;
 413         asp_deferred_session_s deferred_sess;
 414         memcpy(&deferred_sess, input_data, sizeof(asp_deferred_session_s));
 415         deferred_sess.session_id = htonl(deferred_sess.session_id);
 416
 417         if (deferred_sess.deferred_session__response_length <= LENGTH_MAX)
 418                 g_socket_send_to(coordination_protocol_socket, sock_addr,
 419                                  (char *)&deferred_sess, sizeof(asp_deferred_session_s) +
 420                                  deferred_sess.deferred_session__response_length - DEFERRED_INFO_BUF_SIZE, NULL,
 421                                  &error);
 422         else
 423                 return FALSE;
 424
 425         return TRUE;
 426 }
 427
 428 static gboolean asp_coordination_protocol_send_rejected_session(
 429         GSocketAddress *sock_addr, asp_rejected_session_s *input_data)
 430 {
 431         INFO_MSG;
 432
 433         GError *error = NULL;
 434         asp_rejected_session_s rejected_sess;
 435         memcpy(&rejected_sess, input_data, sizeof(asp_rejected_session_s));
 436         rejected_sess.session_id = htonl(rejected_sess.session_id);
 437
 438         g_socket_send_to(coordination_protocol_socket, sock_addr,
 439                          (char *)&rejected_sess, sizeof(asp_rejected_session_s), NULL, &error);
 440
 441         return TRUE;
 442 }
 443
 444 static gboolean asp_coordination_protocol_send_allowed_port(
 445         GSocketAddress *sock_addr, asp_allowed_port_s *input_data)
 446 {
 447         INFO_MSG;
 448
 449         GError *error = NULL;
 450         asp_allowed_port_s allowed_port_data;
 451         memcpy(&allowed_port_data, input_data, sizeof(asp_allowed_port_s));
 452         allowed_port_data.session_id = htonl(allowed_port_data.session_id);
 453
 454         g_socket_send_to(coordination_protocol_socket, sock_addr,
 455                          (char *)&allowed_port_data, sizeof(asp_allowed_port_s), NULL, &error);
 456
 457         return TRUE;
 458 }
 459
 460 static gboolean asp_coordination_protocol_send_request_session(
 461         GSocketAddress *dest_sock_addr, asp_request_session_s *input_data)
 462 {
 463         INFO_MSG;
 464
 465         GError *error = NULL;
 466
 467         asp_request_session_s request_sess;
 468         memcpy(&request_sess, input_data, sizeof(asp_request_session_s));
 469         request_sess.session_id = htonl(request_sess.session_id);
 470         request_sess.advertisement_id = htonl(request_sess.advertisement_id);
 471
 472         if (request_sess.session_information_length <= LENGTH_MAX)
 473                 g_socket_send_to(coordination_protocol_socket, dest_sock_addr,
 474                                  (char *)&request_sess, sizeof(asp_request_session_s) +
 475                                  request_sess.session_information_length - SESSION_INFO_BUF_SIZE, NULL, &error);
 476         else
 477                 return FALSE;
 478
 479         return TRUE;
 480 }
 481
 482 static gboolean asp_coordination_protocol_send_remove_session(
 483         GSocketAddress *sock_addr, asp_remove_session_s *input_data)
 484 {
 485         INFO_MSG;
 486
 487         GError *error = NULL;
 488         asp_remove_session_s remove_sess;
 489         memcpy(&remove_sess, input_data, sizeof(asp_remove_session_s));
 490         remove_sess.session_id = htonl(remove_sess.session_id);
 491
 492         g_socket_send_to(coordination_protocol_socket, sock_addr, (char *)&remove_sess,
 493                          sizeof(asp_remove_session_s), NULL, &error);
 494
 495         return TRUE;
 496 }
 497
 498 static void asp_coordination_protocol_added_session_handler(
 499         GSocketAddress *sock_addr, char *input_data)
 500 {
 501         INFO_MSG;
 502
 503         asp_added_session_s *added_sess = (asp_added_session_s *)input_data;
 504         added_sess->session_id = ntohl(added_sess->session_id);
 505         asp_sess_peer_recv_msg(sock_addr, added_sess);
 506 }
 507
 508 static void asp_coordination_protocol_rejected_session_handler(
 509         GSocketAddress *sock_addr, char *input_data)
 510 {
 511         INFO_MSG;
 512
 513         asp_rejected_session_s *rejected_sess = (asp_rejected_session_s *)input_data;
 514         rejected_sess->session_id = ntohl(rejected_sess->session_id);
 515         asp_sess_peer_recv_msg(sock_addr, rejected_sess);
 516 }
 517
 518 static void asp_coordination_protocol_deferred_session_handler(
 519         GSocketAddress *sock_addr, char *input_data)
 520 {
 521         INFO_MSG;
 522
 523         asp_deferred_session_s *deferred_sess = (asp_deferred_session_s *)input_data;
 524         deferred_sess->session_id = ntohl(deferred_sess->session_id);
 525         asp_sess_peer_recv_msg(sock_addr, deferred_sess);
 526 }