lib/media-util-ipc.c

   1 /*
   2  *  Media Utility
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Yong Yeon Kim <yy9875.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 /**
  23  * This file defines api utilities of IPC.
  24  *
  25  * @file                media-util-ipc.c
  26  * @author      Haejeong Kim(backto.kim@samsung.com)
  27  * @version     1.0
  28  * @brief
  29  */
  30
  31 #include <string.h>
  32 #include <unistd.h>
  33 #include <errno.h>
  34
  35 #include "media-util-dbg.h"
  36 #include "media-util.h"
  37
  38 int ms_ipc_create_client_socket(ms_protocol_e protocol, int timeout_sec, int *sock_fd)
  39 {
  40         int sock = -1;
  41
  42         struct timeval tv_timeout = { timeout_sec, 0 };
  43
  44         if(protocol == MS_PROTOCOL_UDP)
  45         {
  46                 /* Create a datagram/UDP socket */
  47                 if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  48                         MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
  49                         return MS_MEDIA_ERR_SOCKET_CONN;
  50                 }
  51         }
  52         else
  53         {
  54                 /*Create TCP Socket*/
  55                 if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  56                         MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
  57                         return MS_MEDIA_ERR_SOCKET_CONN;
  58                 }
  59         }
  60
  61         if (timeout_sec > 0) {
  62                 if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, &tv_timeout, sizeof(tv_timeout)) == -1) {
  63                         MSAPI_DBG_ERR("setsockopt failed: %s", strerror(errno));
  64                         close(sock);
  65                         return MS_MEDIA_ERR_SOCKET_CONN;
  66                 }
  67         }
  68
  69         *sock_fd = sock;
  70
  71         return MS_MEDIA_ERR_NONE;
  72 }
  73
  74 int ms_ipc_create_server_socket(ms_protocol_e protocol, int port, int *sock_fd)
  75 {
  76         int sock = -1;
  77         int n_reuse = 1;
  78         struct sockaddr_in serv_addr;
  79         unsigned short serv_port;
  80
  81         serv_port = port;
  82
  83         if(protocol == MS_PROTOCOL_UDP)
  84         {
  85                 /* Create a datagram/UDP socket */
  86                 if ((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
  87                         MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
  88                         return MS_MEDIA_ERR_SOCKET_CONN;
  89                 }
  90         }
  91         else
  92         {
  93                 /* Create a TCP socket */
  94                 if ((sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) {
  95                         MSAPI_DBG_ERR("socket failed: %s", strerror(errno));
  96                         return MS_MEDIA_ERR_SOCKET_CONN;
  97                 }
  98         }
  99
 100         if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &n_reuse, sizeof(n_reuse)) == -1) {
 101                 MSAPI_DBG_ERR("setsockopt failed: %s", strerror(errno));
 102                 close(sock);
 103                 return MS_MEDIA_ERR_SOCKET_INTERNAL;
 104         }
 105
 106         memset(&serv_addr, 0, sizeof(serv_addr));
 107         serv_addr.sin_family = AF_INET;
 108 //      serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 109         serv_addr.sin_addr.s_addr = inet_addr(SERVER_IP);
 110         serv_addr.sin_port = htons(serv_port);
 111
 112         /* Bind to the local address */
 113         if (bind(sock, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) < 0) {
 114                 MSAPI_DBG_ERR("bind failed : %s", strerror(errno));
 115                 close(sock);
 116                 return MS_MEDIA_ERR_SOCKET_CONN;
 117         }
 118
 119         MSAPI_DBG("bind success");
 120
 121         /* Listening */
 122         if (protocol == MS_PROTOCOL_TCP) {
 123                 if (listen(sock, SOMAXCONN) < 0) {
 124                         MSAPI_DBG_ERR("listen failed : %s", strerror(errno));
 125                         close(sock);
 126                         return MS_MEDIA_ERR_SOCKET_CONN;
 127                 }
 128
 129                 MSAPI_DBG("Listening...");
 130         }
 131
 132         *sock_fd = sock;
 133
 134         return MS_MEDIA_ERR_NONE;
 135 }
 136
 137 int ms_ipc_send_msg_to_server(int sockfd, int port, ms_comm_msg_s *send_msg, struct sockaddr_in *serv_addr)
 138 {
 139         int res = MS_MEDIA_ERR_NONE;
 140         struct sockaddr_in addr;
 141
 142         /* Set server Address */
 143         memset(&addr, 0, sizeof(addr));
 144         addr.sin_family = AF_INET;
 145         addr.sin_addr.s_addr = inet_addr(SERVER_IP);
 146         addr.sin_port = htons(port);
 147
 148         if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)&addr, sizeof(addr)) != sizeof(*(send_msg))) {
 149                 MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
 150                 res = MS_MEDIA_ERR_SOCKET_SEND;
 151         } else {
 152                 MSAPI_DBG("sent %d", send_msg->result);
 153                 MSAPI_DBG("sent %s", send_msg->msg);
 154                 if (serv_addr != NULL)
 155                         *serv_addr = addr;
 156         }
 157
 158         return res;
 159 }
 160
 161 int ms_ipc_send_msg_to_client(int sockfd, ms_comm_msg_s *send_msg, struct sockaddr_in *client_addr)
 162 {
 163         int res = MS_MEDIA_ERR_NONE;
 164
 165         if (sendto(sockfd, send_msg, sizeof(*(send_msg)), 0, (struct sockaddr *)client_addr, sizeof(*(client_addr))) != sizeof(*(send_msg))) {
 166                 MSAPI_DBG_ERR("sendto failed [%s]", strerror(errno));
 167                 res = MS_MEDIA_ERR_SOCKET_SEND;
 168         } else {
 169                 MSAPI_DBG("sent %d", send_msg->result);
 170                 MSAPI_DBG("sent %s", send_msg->msg);
 171         }
 172
 173         return MS_MEDIA_ERR_NONE;
 174 }
 175
 176 int ms_ipc_receive_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
 177 {
 178         int recv_msg_size;
 179         struct sockaddr_in addr;
 180         socklen_t addr_len;
 181
 182         if (!recv_msg)
 183                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 184
 185         addr_len = sizeof(struct sockaddr_in);
 186
 187         if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)&addr, &addr_len)) < 0) {
 188                 MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
 189                 return MS_MEDIA_ERR_SOCKET_RECEIVE;
 190         }
 191
 192         if (recv_addr != NULL)
 193                 *recv_addr = addr;
 194         if (addr_size != NULL)
 195                 *addr_size  = addr_len;
 196
 197         return MS_MEDIA_ERR_NONE;
 198 }
 199
 200 int ms_ipc_wait_message(int sockfd, void *recv_msg, unsigned int msg_size, struct sockaddr_in *recv_addr, unsigned int *addr_size)
 201 {
 202         int recv_msg_size;
 203         socklen_t addr_len;
 204
 205         if (!recv_msg ||!recv_addr)
 206                 return MS_MEDIA_ERR_INVALID_PARAMETER;
 207
 208         addr_len = sizeof(struct sockaddr_in);
 209
 210         if ((recv_msg_size = recvfrom(sockfd, recv_msg, msg_size, 0, (struct sockaddr *)recv_addr, &addr_len)) < 0) {
 211                 MSAPI_DBG_ERR("recvfrom failed [%s]", strerror(errno));
 212                 if (errno == EWOULDBLOCK) {
 213                         MSAPI_DBG_ERR("recvfrom Timeout.");
 214                         return MS_MEDIA_ERR_SOCKET_RECEIVE_TIMEOUT;
 215                 } else {
 216                         MSAPI_DBG_ERR("recvfrom error [%s]", strerror(errno));
 217                         return MS_MEDIA_ERR_SOCKET_RECEIVE;
 218                 }
 219         }
 220
 221         if (addr_size != NULL)
 222                 *addr_size  = addr_len;
 223
 224         return MS_MEDIA_ERR_NONE;
 225 }
 226
 227