src/co_ss.c

   1 /*
   2  * libtcore
   3  *
   4  * Copyright (c) 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Ja-young Gu <jygu@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 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <glib.h>
  26
  27 #include "tcore.h"
  28 #include "plugin.h"
  29 #include "queue.h"
  30 #include "user_request.h"
  31 #include "co_ss.h"
  32
  33 #define _check_null( name, value, err ) { \
  34         if ( !value ) { \
  35                 dbg("[error] %s : NULL", name ); \
  36                 return err; \
  37         } \
  38 }
  39
  40 struct ussd_session {
  41         gboolean session;
  42         enum tcore_ss_ussd_type type;
  43         void* data;
  44         int data_len;
  45 };
  46
  47 struct private_object_data {
  48         struct ussd_session ussd_s;
  49         struct tcore_ss_operations *ops;
  50 };
  51
  52 static TReturn _dispatcher(CoreObject *o, UserRequest *ur)
  53 {
  54         enum tcore_request_command command;
  55         TReturn ret = 0;
  56
  57         struct private_object_data *po = NULL;
  58         po = tcore_object_ref_object(o);
  59
  60         _check_null( "po", po, TCORE_RETURN_FAILURE);
  61         _check_null( "po->ops", po->ops, TCORE_RETURN_FAILURE);
  62         _check_null( "ur", ur, TCORE_RETURN_FAILURE);
  63
  64         command = tcore_user_request_get_command(ur);
  65         switch (command) {
  66                 case TREQ_SS_BARRING_ACTIVATE:
  67                         ret = po->ops->barring_activate(o, ur);
  68                         break;
  69
  70                 case TREQ_SS_BARRING_DEACTIVATE:
  71                         ret = po->ops->barring_deactivate(o, ur);
  72                         break;
  73
  74                 case TREQ_SS_BARRING_CHANGE_PASSWORD:
  75                         ret = po->ops->barring_change_password(o, ur);
  76                         break;
  77
  78                 case TREQ_SS_BARRING_GET_STATUS:
  79                         ret = po->ops->barring_get_status(o, ur);
  80                         break;
  81
  82                 case TREQ_SS_FORWARDING_ACTIVATE:
  83                         ret = po->ops->forwarding_activate(o, ur);
  84                         break;
  85
  86                 case TREQ_SS_FORWARDING_DEACTIVATE:
  87                         ret = po->ops->forwarding_deactivate(o, ur);
  88                         break;
  89
  90                 case TREQ_SS_FORWARDING_REGISTER:
  91                         ret = po->ops->forwarding_register(o, ur);
  92                         break;
  93
  94                 case TREQ_SS_FORWARDING_DEREGISTER:
  95                         ret = po->ops->forwarding_deregister(o, ur);
  96                         break;
  97
  98                 case TREQ_SS_FORWARDING_GET_STATUS:
  99                         ret = po->ops->forwarding_get_status(o, ur);
 100                         break;
 101
 102                 case TREQ_SS_WAITING_ACTIVATE:
 103                         ret = po->ops->waiting_activate(o, ur);
 104                         break;
 105
 106                 case TREQ_SS_WAITING_DEACTIVATE:
 107                         ret = po->ops->waiting_deactivate(o, ur);
 108                         break;
 109
 110                 case TREQ_SS_WAITING_GET_STATUS:
 111                         ret = po->ops->waiting_get_status(o, ur);
 112                         break;
 113
 114                 case TREQ_SS_CLI_ACTIVATE:
 115                         ret = po->ops->cli_activate(o, ur);
 116                         break;
 117
 118                 case TREQ_SS_CLI_DEACTIVATE:
 119                         ret = po->ops->cli_deactivate(o, ur);
 120                         break;
 121
 122                 case TREQ_SS_CLI_GET_STATUS:
 123                         ret = po->ops->cli_get_status(o, ur);
 124                         break;
 125
 126                 case TREQ_SS_SEND_USSD:
 127                         ret = po->ops->send_ussd(o, ur);
 128                         break;
 129
 130                 case TREQ_SS_SET_AOC:
 131                         ret = po->ops->set_aoc(o, ur);
 132                         break;
 133
 134                 case TREQ_SS_GET_AOC:
 135                         ret = po->ops->get_aoc(o, ur);
 136                         break;
 137
 138                 default:
 139                         break;
 140         }
 141
 142         return ret;
 143 }
 144
 145 static void _clone_hook(CoreObject *src, CoreObject *dest)
 146 {
 147         struct private_object_data *src_po = NULL;
 148         struct private_object_data *dest_po = NULL;
 149
 150         if (!src || !dest)
 151                 return;
 152
 153         dest_po = calloc(sizeof(struct private_object_data), 1);
 154         if (!dest_po) {
 155                 tcore_object_link_object(dest, NULL);
 156                 return;
 157         }
 158
 159         src_po = tcore_object_ref_object(src);
 160         dest_po->ops = src_po->ops;
 161
 162         tcore_object_link_object(dest, dest_po);
 163 }
 164
 165 static void _free_hook(CoreObject *o)
 166 {
 167         struct private_object_data *po = NULL;
 168
 169         po = tcore_object_ref_object(o);
 170         if (!po)
 171                 return;
 172
 173         free(po);
 174         tcore_object_link_object(o, NULL);
 175 }
 176
 177 static void _ussd_session_init(struct ussd_session *ussd_s)
 178 {
 179         ussd_s->session = FALSE;
 180         ussd_s->type = 0;
 181         ussd_s->data = 0;
 182         ussd_s->data_len = 0;
 183 }
 184
 185 struct ussd_session* tcore_ss_ussd_create_session(CoreObject *o,
 186                 enum tcore_ss_ussd_type type, void *data, int data_len)
 187 {
 188         struct private_object_data *po = NULL;
 189
 190         po = tcore_object_ref_object(o);
 191         if (!po)
 192                 return 0;
 193
 194         if (type < TCORE_SS_USSD_TYPE_USER_INITIATED
 195                         || type > TCORE_SS_USSD_TYPE_NETWORK_INITIATED) {
 196                 dbg("[ error ] wrong ussd type : (0x%x)", type);
 197                 return 0;
 198         }
 199
 200         if (!po->ussd_s.session) {
 201                 po->ussd_s.session = TRUE;
 202                 po->ussd_s.type = type;
 203                 po->ussd_s.data = data;
 204
 205                 if (data_len < 0)
 206                         po->ussd_s.data_len = 0;
 207                 else
 208                         po->ussd_s.data_len = data_len;
 209
 210                 return &po->ussd_s;
 211
 212         }
 213         else {
 214                 dbg("[ error ] already exist ussd session, type : (0x%x)", po->ussd_s.type);
 215                 return 0;
 216         }
 217 }
 218
 219 void tcore_ss_ussd_destroy_session(struct ussd_session *ussd_s)
 220 {
 221         if (!ussd_s || !ussd_s->session) {
 222                 return;
 223         }
 224         else {
 225
 226                 _ussd_session_init(ussd_s);
 227         }
 228 }
 229
 230 struct ussd_session* tcore_ss_ussd_get_session(CoreObject *o)
 231 {
 232         struct private_object_data *po = NULL;
 233
 234         po = tcore_object_ref_object(o);
 235         if (!po)
 236                 return 0;
 237
 238         if (!po->ussd_s.session)
 239                 return 0;
 240         else
 241                 return &po->ussd_s;
 242 }
 243
 244 enum tcore_ss_ussd_type tcore_ss_ussd_get_session_type(struct ussd_session *ussd_s)
 245 {
 246         if (!ussd_s || !ussd_s->session) {
 247                 dbg("[ error ] there is no session");
 248                 return 0;
 249
 250         }
 251         else {
 252                 return ussd_s->type;
 253         }
 254 }
 255
 256 void tcore_ss_ussd_set_session_type(struct ussd_session *ussd_s,
 257                 enum tcore_ss_ussd_type type)
 258 {
 259         if (!ussd_s || !ussd_s->session) {
 260                 dbg("[ error ] there is no session");
 261                 return;
 262
 263         }
 264         else {
 265                 ussd_s->type = type;
 266         }
 267 }
 268
 269 int tcore_ss_ussd_get_session_data(struct ussd_session* ussd_s, void **data)
 270 {
 271         if (!ussd_s || !ussd_s->session) {
 272                 dbg("[ error ] there is no session");
 273                 return -1;
 274
 275         }
 276         else {
 277
 278                 *data = ussd_s->data;
 279                 return ussd_s->data_len;
 280         }
 281 }
 282
 283 CoreObject *tcore_ss_new(TcorePlugin *p, const char *name,
 284                 struct tcore_ss_operations *ops, TcoreHal *hal)
 285 {
 286         CoreObject *o = NULL;
 287         struct private_object_data *po = NULL;
 288
 289         if (!p)
 290                 return NULL;
 291
 292         o = tcore_object_new(p, name, hal);
 293         if (!o)
 294                 return NULL;
 295
 296         po = calloc(sizeof(struct private_object_data), 1);
 297         if (!po) {
 298                 tcore_object_free(o);
 299                 return NULL;
 300         }
 301
 302         po->ops = ops;
 303
 304         _ussd_session_init(&po->ussd_s);
 305
 306         tcore_object_set_type(o, CORE_OBJECT_TYPE_SS);
 307         tcore_object_link_object(o, po);
 308         tcore_object_set_free_hook(o, _free_hook);
 309         tcore_object_set_clone_hook(o, _clone_hook);
 310         tcore_object_set_dispatcher(o, _dispatcher);
 311
 312         return o;
 313 }
 314
 315 void tcore_ss_free(CoreObject *o)
 316 {
 317         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_SS);
 318
 319         tcore_object_free(o);
 320 }