src/co_context.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 "util.h"
  29 #include "plugin.h"
  30 #include "user_request.h"
  31 #include "co_context.h"
  32
  33 struct private_object_data {
  34         enum co_context_state state;
  35         unsigned char id;
  36         enum co_context_role role;
  37         gboolean default_profile;
  38         gboolean attach_apn;
  39
  40         char *apn;
  41         char *addr;
  42         enum co_context_type type;
  43         enum co_context_d_comp d_comp;
  44         enum co_context_h_comp h_comp;
  45         enum co_context_tech tech_pref;
  46         char *username;
  47         char *password;
  48         char *dns1;
  49         char *dns2;
  50         enum co_context_auth auth;
  51
  52         union tcore_ip4_type ip_v4;
  53         union tcore_ip4_type gateway_v4;
  54         union tcore_ip4_type dns_primary_v4;
  55         union tcore_ip4_type dns_secondary_v4;
  56
  57         /* IPv6 will be supported */
  58         char *ip_v6;
  59         char *gateway_v6;
  60         char *dns_primary_v6;
  61         char *dns_secondary_v6;
  62
  63         pcscf_addr *pcscf_ipv4;
  64         pcscf_addr *pcscf_ipv6;
  65
  66         char *proxy;
  67         char *mmsurl;
  68         char *profile_name;
  69         char devname[16];
  70
  71         /* Dedicated bearer information */
  72         struct dedicated_bearer_info dedicated_bearer;
  73 };
  74
  75 static void _free_hook(CoreObject *o)
  76 {
  77         struct private_object_data *po = NULL;
  78
  79         po = tcore_object_ref_object(o);
  80         if (po) {
  81                 free(po);
  82                 tcore_object_link_object(o, NULL);
  83         }
  84 }
  85
  86 CoreObject *tcore_context_new(TcorePlugin *p, const char *name, TcoreHal *hal)
  87 {
  88         CoreObject *o = NULL;
  89         struct private_object_data *po = NULL;
  90
  91         if (!p)
  92                 return NULL;
  93
  94         o = tcore_object_new(p, name, hal);
  95         if (!o)
  96                 return NULL;
  97
  98         po = calloc(1, sizeof(struct private_object_data));
  99         if (!po) {
 100                 tcore_object_free(o);
 101                 return NULL;
 102         }
 103
 104         po->type = CONTEXT_TYPE_IP;
 105         po->d_comp = CONTEXT_D_COMP_OFF;
 106         po->h_comp = CONTEXT_H_COMP_OFF;
 107         po->role = CONTEXT_ROLE_UNKNOWN;
 108         po->auth = CONTEXT_AUTH_NONE;
 109         po->tech_pref = CONTEXT_TECH_3GPP;
 110
 111         tcore_object_set_type(o, CORE_OBJECT_TYPE_PS_CONTEXT);
 112         tcore_object_link_object(o, po);
 113         tcore_object_set_free_hook(o, _free_hook);
 114
 115         return o;
 116 }
 117
 118 void tcore_context_free(CoreObject *o)
 119 {
 120         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_PS_CONTEXT);
 121         tcore_object_free(o);
 122 }
 123
 124 TReturn tcore_context_set_state(CoreObject *o, enum co_context_state state)
 125 {
 126         struct private_object_data *po = NULL;
 127
 128         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 129
 130         po = tcore_object_ref_object(o);
 131         if (!po)
 132                 return TCORE_RETURN_EINVAL;
 133
 134         po->state = state;
 135
 136         return TCORE_RETURN_SUCCESS;
 137 }
 138
 139 enum co_context_state    tcore_context_get_state(CoreObject *o)
 140 {
 141         struct private_object_data *po = NULL;
 142
 143         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 144
 145         po = tcore_object_ref_object(o);
 146         if (!po)
 147                 return 0;
 148
 149         return po->state;
 150 }
 151
 152 TReturn tcore_context_set_id(CoreObject *o, unsigned char id)
 153 {
 154         struct private_object_data *po = NULL;
 155
 156         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 157
 158         po = tcore_object_ref_object(o);
 159         if (!po)
 160                 return TCORE_RETURN_EINVAL;
 161
 162         po->id = id;
 163
 164         return TCORE_RETURN_SUCCESS;
 165 }
 166
 167 unsigned char  tcore_context_get_id(CoreObject *o)
 168 {
 169         struct private_object_data *po = NULL;
 170
 171         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 172
 173         po = tcore_object_ref_object(o);
 174         if (!po)
 175                 return 0;
 176
 177         return po->id;
 178 }
 179
 180 TReturn tcore_context_set_apn(CoreObject *o, const char *apn)
 181 {
 182         struct private_object_data *po = NULL;
 183
 184         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 185
 186         po = tcore_object_ref_object(o);
 187         if (!po)
 188                 return FALSE;
 189
 190         if (po->apn) {
 191                 free(po->apn);
 192                 po->apn = NULL;
 193         }
 194
 195         if (apn)
 196                 po->apn = g_strdup(apn);
 197
 198         return TCORE_RETURN_SUCCESS;
 199 }
 200
 201 char *tcore_context_get_apn(CoreObject *o)
 202 {
 203         struct private_object_data *po = NULL;
 204
 205         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 206
 207         po = tcore_object_ref_object(o);
 208         if (!po)
 209                 return NULL;
 210
 211         if (!po->apn)
 212                 return NULL;
 213
 214         return g_strdup(po->apn);
 215 }
 216
 217 TReturn tcore_context_set_address(CoreObject *o, const char *addr)
 218 {
 219         struct private_object_data *po = NULL;
 220
 221         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 222
 223         po = tcore_object_ref_object(o);
 224         if (!po)
 225                 return TCORE_RETURN_EINVAL;
 226
 227         if (po->addr) {
 228                 free(po->addr);
 229                 po->addr = NULL;
 230         }
 231
 232         if (addr)
 233                 po->addr = g_strdup(addr);
 234
 235         return TCORE_RETURN_SUCCESS;
 236 }
 237
 238 char *tcore_context_get_address(CoreObject *o)
 239 {
 240         struct private_object_data *po = NULL;
 241
 242         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 243
 244         po = tcore_object_ref_object(o);
 245         if (!po)
 246                 return NULL;
 247
 248         if (!po->addr)
 249                 return NULL;
 250
 251         return g_strdup(po->addr);
 252 }
 253
 254 TReturn tcore_context_set_role(CoreObject *o, enum co_context_role role)
 255 {
 256         struct private_object_data *po = NULL;
 257
 258         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 259
 260         po = tcore_object_ref_object(o);
 261         if (!po)
 262                 return TCORE_RETURN_EINVAL;
 263
 264         po->role = role;
 265
 266         return TCORE_RETURN_SUCCESS;
 267 }
 268
 269 enum co_context_role tcore_context_get_role(CoreObject *o)
 270 {
 271         struct private_object_data *po = NULL;
 272
 273         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 274
 275         po = tcore_object_ref_object(o);
 276         if (!po)
 277                 return 0;
 278
 279         return po->role;
 280 }
 281
 282 TReturn tcore_context_set_type(CoreObject *o, enum co_context_type type)
 283 {
 284         struct private_object_data *po = NULL;
 285
 286         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 287
 288         po = tcore_object_ref_object(o);
 289         if (!po)
 290                 return TCORE_RETURN_EINVAL;
 291
 292         po->type = type;
 293
 294         return TCORE_RETURN_SUCCESS;
 295 }
 296
 297 enum co_context_type tcore_context_get_type(CoreObject *o)
 298 {
 299         struct private_object_data *po = NULL;
 300
 301         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 302
 303         po = tcore_object_ref_object(o);
 304         if (!po)
 305                 return 0;
 306
 307         return po->type;
 308 }
 309
 310 TReturn tcore_context_set_data_compression(CoreObject *o, enum co_context_d_comp comp)
 311 {
 312         struct private_object_data *po = NULL;
 313
 314         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 315
 316         po = tcore_object_ref_object(o);
 317         if (!po)
 318                 return TCORE_RETURN_EINVAL;
 319
 320         po->d_comp = comp;
 321
 322         return TCORE_RETURN_SUCCESS;
 323 }
 324
 325 enum co_context_d_comp tcore_context_get_data_compression(CoreObject *o)
 326 {
 327         struct private_object_data *po = NULL;
 328
 329         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 330
 331         po = tcore_object_ref_object(o);
 332         if (!po)
 333                 return 0;
 334
 335         return po->d_comp;
 336 }
 337
 338 TReturn tcore_context_set_header_compression(CoreObject *o, enum co_context_h_comp comp)
 339 {
 340         struct private_object_data *po = NULL;
 341
 342         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 343
 344         po = tcore_object_ref_object(o);
 345         if (!po)
 346                 return TCORE_RETURN_EINVAL;
 347
 348         po->h_comp = comp;
 349
 350         return TCORE_RETURN_SUCCESS;
 351 }
 352
 353 enum co_context_h_comp tcore_context_get_header_compression(CoreObject *o)
 354 {
 355         struct private_object_data *po = NULL;
 356
 357         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 358
 359         po = tcore_object_ref_object(o);
 360         if (!po)
 361                 return 0;
 362
 363         return po->h_comp;
 364 }
 365
 366 TReturn tcore_context_set_tech_preference(CoreObject *o, enum co_context_tech tech)
 367 {
 368         struct private_object_data *po = NULL;
 369
 370         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 371
 372         po = tcore_object_ref_object(o);
 373         if (!po)
 374                 return TCORE_RETURN_EINVAL;
 375
 376         po->tech_pref = tech;
 377
 378         return TCORE_RETURN_SUCCESS;
 379 }
 380
 381 enum co_context_tech tcore_context_get_tech_preference(CoreObject *o)
 382 {
 383         struct private_object_data *po = NULL;
 384
 385         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 386
 387         po = tcore_object_ref_object(o);
 388         if (!po)
 389                 return CONTEXT_TECH_INVALID;
 390
 391         return po->tech_pref;
 392 }
 393
 394 TReturn tcore_context_set_username(CoreObject *o, const char *username)
 395 {
 396         struct private_object_data *po = NULL;
 397
 398         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 399
 400         po = tcore_object_ref_object(o);
 401         if (!po)
 402                 return TCORE_RETURN_EINVAL;
 403
 404         if (po->username) {
 405                 free(po->username);
 406                 po->username = NULL;
 407         }
 408
 409         if (username)
 410                 po->username = g_strdup(username);
 411
 412         return TCORE_RETURN_SUCCESS;
 413 }
 414
 415 char *tcore_context_get_username(CoreObject *o)
 416 {
 417         struct private_object_data *po = NULL;
 418
 419         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 420
 421         po = tcore_object_ref_object(o);
 422         if (!po)
 423                 return NULL;
 424
 425         if (!po->username)
 426                 return NULL;
 427
 428         return g_strdup(po->username);
 429 }
 430
 431 TReturn tcore_context_set_password(CoreObject *o, const char *password)
 432 {
 433         struct private_object_data *po = NULL;
 434
 435         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 436
 437         po = tcore_object_ref_object(o);
 438         if (!po)
 439                 return TCORE_RETURN_EINVAL;
 440
 441         if (po->password) {
 442                 free(po->password);
 443                 po->password = NULL;
 444         }
 445
 446         if (password)
 447                 po->password = g_strdup(password);
 448
 449         return TCORE_RETURN_SUCCESS;
 450 }
 451
 452 char *tcore_context_get_password(CoreObject *o)
 453 {
 454         struct private_object_data *po = NULL;
 455
 456         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 457
 458         po = tcore_object_ref_object(o);
 459         if (!po)
 460                 return NULL;
 461
 462         if (!po->password)
 463                 return NULL;
 464
 465         return g_strdup(po->password);
 466 }
 467
 468 TReturn tcore_context_set_dns1(CoreObject *o, const char *dns)
 469 {
 470         struct private_object_data *po = NULL;
 471
 472         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 473
 474         po = tcore_object_ref_object(o);
 475         if (!po)
 476                 return TCORE_RETURN_EINVAL;
 477
 478         if (po->dns1) {
 479                 free(po->dns1);
 480                 po->dns1 = NULL;
 481         }
 482
 483         if (dns)
 484                 po->dns1 = g_strdup(dns);
 485
 486         return TCORE_RETURN_SUCCESS;
 487 }
 488
 489 TReturn tcore_context_set_ipv6_dns1(CoreObject *o, const char *dns)
 490 {
 491         struct private_object_data *po = NULL;
 492
 493         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 494
 495         po = tcore_object_ref_object(o);
 496         if (!po)
 497                 return TCORE_RETURN_EINVAL;
 498
 499         if (po->dns_primary_v6) {
 500                 free(po->dns_primary_v6);
 501                 po->dns_primary_v6 = NULL;
 502         }
 503
 504         if (dns)
 505                 po->dns_primary_v6 = g_strdup(dns);
 506
 507         return TCORE_RETURN_SUCCESS;
 508 }
 509
 510 char *tcore_context_get_dns1(CoreObject *o)
 511 {
 512         struct private_object_data *po = NULL;
 513
 514         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 515
 516         po = tcore_object_ref_object(o);
 517         if (!po)
 518                 return NULL;
 519
 520         if (!po->dns1)
 521                 return NULL;
 522
 523         return g_strdup(po->dns1);
 524 }
 525
 526 TReturn tcore_context_set_dns2(CoreObject *o, const char *dns)
 527 {
 528         struct private_object_data *po = NULL;
 529
 530         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 531
 532         po = tcore_object_ref_object(o);
 533         if (!po)
 534                 return TCORE_RETURN_EINVAL;
 535
 536         if (po->dns2) {
 537                 free(po->dns2);
 538                 po->dns2 = NULL;
 539         }
 540
 541         if (dns)
 542                 po->dns2 = g_strdup(dns);
 543
 544         return TCORE_RETURN_SUCCESS;
 545 }
 546
 547 TReturn tcore_context_set_ipv6_dns2(CoreObject *o, const char *dns)
 548 {
 549         struct private_object_data *po = NULL;
 550
 551         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 552
 553         po = tcore_object_ref_object(o);
 554         if (!po)
 555                 return TCORE_RETURN_EINVAL;
 556
 557         if (po->dns_secondary_v6) {
 558                 free(po->dns_secondary_v6);
 559                 po->dns_secondary_v6 = NULL;
 560         }
 561
 562         if (dns)
 563                 po->dns_secondary_v6 = g_strdup(dns);
 564
 565         return TCORE_RETURN_SUCCESS;
 566 }
 567
 568 char *tcore_context_get_dns2(CoreObject *o)
 569 {
 570         struct private_object_data *po = NULL;
 571
 572         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 573
 574         po = tcore_object_ref_object(o);
 575         if (!po)
 576                 return NULL;
 577
 578         if (!po->dns2)
 579                 return NULL;
 580
 581         return g_strdup(po->dns2);
 582 }
 583
 584 TReturn tcore_context_set_auth(CoreObject *o, enum co_context_auth auth)
 585 {
 586         struct private_object_data *po = NULL;
 587
 588         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 589
 590         po = tcore_object_ref_object(o);
 591         if (!po)
 592                 return TCORE_RETURN_EINVAL;
 593
 594         po->auth = auth;
 595
 596         return TCORE_RETURN_SUCCESS;
 597 }
 598
 599 enum co_context_auth tcore_context_get_auth(CoreObject *o)
 600 {
 601         struct private_object_data *po = NULL;
 602
 603         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 604
 605         po = tcore_object_ref_object(o);
 606         if (!po)
 607                 return 0;
 608
 609         return po->auth;
 610 }
 611
 612 TReturn tcore_context_set_proxy(CoreObject *o, const char *proxy)
 613 {
 614         struct private_object_data *po = NULL;
 615
 616         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 617
 618         po = tcore_object_ref_object(o);
 619         if (!po)
 620                 return FALSE;
 621
 622         if (po->proxy) {
 623                 free(po->proxy);
 624                 po->apn = NULL;
 625         }
 626
 627         if (proxy)
 628                 po->proxy = g_strdup(proxy);
 629
 630         return TCORE_RETURN_SUCCESS;
 631 }
 632
 633 char *tcore_context_get_proxy(CoreObject *o)
 634 {
 635         struct private_object_data *po = NULL;
 636
 637         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 638
 639         po = tcore_object_ref_object(o);
 640         if (!po)
 641                 return NULL;
 642
 643         if (!po->proxy)
 644                 return NULL;
 645
 646         return g_strdup(po->proxy);
 647 }
 648
 649 TReturn tcore_context_set_mmsurl(CoreObject *o, const char *mmsurl)
 650 {
 651         struct private_object_data *po = NULL;
 652
 653         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 654
 655         po = tcore_object_ref_object(o);
 656         if (!po)
 657                 return FALSE;
 658
 659         if (po->mmsurl) {
 660                 free(po->mmsurl);
 661                 po->mmsurl = NULL;
 662         }
 663
 664         if (mmsurl)
 665                 po->mmsurl = g_strdup(mmsurl);
 666
 667         return TCORE_RETURN_SUCCESS;
 668 }
 669
 670 char *tcore_context_get_mmsurl(CoreObject *o)
 671 {
 672         struct private_object_data *po = NULL;
 673
 674         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 675
 676         po = tcore_object_ref_object(o);
 677         if (!po)
 678                 return NULL;
 679
 680         if (!po->mmsurl)
 681                 return NULL;
 682
 683         return g_strdup(po->mmsurl);
 684 }
 685
 686 TReturn tcore_context_set_profile_name(CoreObject *o, const char *profile_name)
 687 {
 688         struct private_object_data *po = NULL;
 689
 690         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 691
 692         po = tcore_object_ref_object(o);
 693         if (!po)
 694                 return FALSE;
 695
 696         if (po->profile_name) {
 697                 free(po->profile_name);
 698                 po->profile_name = NULL;
 699         }
 700
 701         if (profile_name)
 702                 po->profile_name = g_strdup(profile_name);
 703
 704         return TCORE_RETURN_SUCCESS;
 705 }
 706
 707 char *tcore_context_get_profile_name(CoreObject *o)
 708 {
 709         struct private_object_data *po = NULL;
 710
 711         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 712
 713         po = tcore_object_ref_object(o);
 714         if (!po)
 715                 return NULL;
 716
 717         if (!po->profile_name)
 718                 return NULL;
 719
 720         return g_strdup(po->profile_name);
 721 }
 722
 723 TReturn tcore_context_set_default_profile(CoreObject *o, gboolean default_conn)
 724 {
 725         struct private_object_data *po = NULL;
 726
 727         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 728
 729         po = tcore_object_ref_object(o);
 730         if (!po)
 731                 return TCORE_RETURN_EINVAL;
 732
 733         po->default_profile = default_conn;
 734
 735         return TCORE_RETURN_SUCCESS;
 736 }
 737
 738 gboolean tcore_context_get_default_profile(CoreObject *o)
 739 {
 740         struct private_object_data *po = NULL;
 741
 742         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 743
 744         po = tcore_object_ref_object(o);
 745         if (!po)
 746                 return FALSE;
 747
 748         return po->default_profile;
 749 }
 750
 751 TReturn tcore_context_set_devinfo(CoreObject *o, struct tnoti_ps_pdp_ipconfiguration *devinfo)
 752 {
 753         struct private_object_data *po = NULL;
 754
 755         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 756
 757         po = tcore_object_ref_object(o);
 758
 759         if (!po || !devinfo)
 760                 return TCORE_RETURN_EINVAL;
 761
 762         /* Free context resource if it was already allocated */
 763         tcore_context_reset_devinfo(o);
 764
 765         po->ip_v6 = g_strdup((gchar *)devinfo->ipv6_address);
 766         po->dns_primary_v6 = g_strdup((gchar *)devinfo->ipv6_primary_dns);
 767         po->dns_secondary_v6 = g_strdup((gchar *)devinfo->ipv6_secondary_dns);
 768         po->gateway_v6 = g_strdup((gchar *)devinfo->ipv6_gateway);
 769         memcpy(&(po->ip_v4), devinfo->ip_address, sizeof(union tcore_ip4_type));
 770         memcpy(&(po->dns_primary_v4), devinfo->primary_dns, sizeof(union tcore_ip4_type));
 771         memcpy(&(po->dns_secondary_v4), devinfo->secondary_dns, sizeof(union tcore_ip4_type));
 772         memcpy(&(po->gateway_v4), devinfo->gateway, sizeof(union tcore_ip4_type));
 773         memcpy(po->devname, devinfo->devname, sizeof(char) * 16);
 774
 775         po->pcscf_ipv4 = g_try_malloc0(sizeof(pcscf_addr));
 776         if (po->pcscf_ipv4) {
 777                 po->pcscf_ipv4->count = devinfo->pcscf_ipv4_count;
 778                 if (po->pcscf_ipv4->count > 0) {
 779                         unsigned int i;
 780                         po->pcscf_ipv4->addr = g_try_malloc0(sizeof(char *) * po->pcscf_ipv4->count);
 781                         if ((po->pcscf_ipv4->addr) && (devinfo->pcscf_ipv4))
 782                                 for (i = 0; i < po->pcscf_ipv4->count; i++)
 783                                         po->pcscf_ipv4->addr[i] = g_strdup(devinfo->pcscf_ipv4[i]);
 784                 }
 785         }
 786
 787         po->pcscf_ipv6 = g_try_malloc0(sizeof(pcscf_addr));
 788         if (po->pcscf_ipv6) {
 789                 po->pcscf_ipv6->count = devinfo->pcscf_ipv6_count;
 790                 if (po->pcscf_ipv6->count > 0) {
 791                         unsigned int i;
 792                         po->pcscf_ipv6->addr = g_try_malloc0(sizeof(char *) * po->pcscf_ipv6->count);
 793                         if ((po->pcscf_ipv6->addr) && (devinfo->pcscf_ipv6))
 794                                 for (i = 0; i < po->pcscf_ipv6->count; i++)
 795                                         po->pcscf_ipv6->addr[i] = g_strdup(devinfo->pcscf_ipv6[i]);
 796                 }
 797         }
 798
 799         return TCORE_RETURN_SUCCESS;
 800 }
 801
 802 TReturn tcore_context_reset_devinfo(CoreObject *o)
 803 {
 804         struct private_object_data *po = NULL;
 805         unsigned int i;
 806
 807         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 808
 809         po = tcore_object_ref_object(o);
 810         if (!po)
 811                 return TCORE_RETURN_EINVAL;
 812
 813         if (po->ip_v6) {
 814                 g_free(po->ip_v6);
 815                 po->ip_v6 = NULL;
 816         }
 817
 818         if (po->dns_primary_v6) {
 819                 g_free(po->dns_primary_v6);
 820                 po->dns_primary_v6 = NULL;
 821         }
 822
 823         if (po->dns_secondary_v6) {
 824                 g_free(po->dns_secondary_v6);
 825                 po->dns_secondary_v6 = NULL;
 826         }
 827
 828         if (po->gateway_v6) {
 829                 g_free(po->gateway_v6);
 830                 po->gateway_v6 = NULL;
 831         }
 832
 833         if (po->pcscf_ipv4) {
 834                 for (i = 0; i < po->pcscf_ipv4->count; i++)
 835                         g_free(po->pcscf_ipv4->addr[i]);
 836                 g_free(po->pcscf_ipv4);
 837                 po->pcscf_ipv4 = NULL;
 838         }
 839
 840         if (po->pcscf_ipv6) {
 841                 for (i = 0; i < po->pcscf_ipv6->count; i++)
 842                         g_free(po->pcscf_ipv6->addr[i]);
 843                 g_free(po->pcscf_ipv6);
 844                 po->pcscf_ipv6 = NULL;
 845         }
 846
 847         memset(&(po->ip_v4), 0, sizeof(union tcore_ip4_type));
 848         memset(&(po->dns_primary_v4), 0, sizeof(union tcore_ip4_type));
 849         memset(&(po->dns_secondary_v4), 0, sizeof(union tcore_ip4_type));
 850         memset(&(po->gateway_v4), 0, sizeof(union tcore_ip4_type));
 851         memset(po->devname, 0, sizeof(char) * 16);
 852
 853         return TCORE_RETURN_SUCCESS;
 854 }
 855
 856 TReturn tcore_context_set_bearer_info(CoreObject *o, struct tnoti_ps_dedicated_bearer_info *bearer_info)
 857 {
 858         struct private_object_data *po = NULL;
 859
 860         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 861
 862         po = tcore_object_ref_object(o);
 863         if (!po)
 864                 return TCORE_RETURN_EINVAL;
 865
 866         if (!bearer_info)
 867                 return TCORE_RETURN_EINVAL;
 868
 869         if (bearer_info->dedicated_bearer.num_dedicated_bearer > 0)
 870                 memcpy(&(po->dedicated_bearer), &(bearer_info->dedicated_bearer), sizeof(struct dedicated_bearer_info));
 871
 872         return TCORE_RETURN_SUCCESS;
 873 }
 874
 875 TReturn tcore_context_get_bearer_info(CoreObject *o, struct dedicated_bearer_info *bearer_info)
 876 {
 877         struct private_object_data *po = NULL;
 878         guchar count = 0;
 879
 880         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 881
 882         po = tcore_object_ref_object(o);
 883         if (!po)
 884                 return TCORE_RETURN_EINVAL;
 885
 886         if (!bearer_info)
 887                 return TCORE_RETURN_EINVAL;
 888
 889         count = po->dedicated_bearer.num_dedicated_bearer;
 890         if (count > MAX_NUM_DEDICATED_BEARER)
 891                 return TCORE_RETURN_EINVAL;
 892
 893         if (count > 0) {
 894                 bearer_info->num_dedicated_bearer = count;
 895                 bearer_info->secondary_context_id = po->dedicated_bearer.secondary_context_id;
 896                 memcpy(bearer_info->qos, po->dedicated_bearer.qos, count*sizeof(struct qos_parameter));
 897         }
 898
 899         return TCORE_RETURN_SUCCESS;
 900 }
 901
 902 TReturn tcore_context_reset_bearer_info(CoreObject *o)
 903 {
 904         struct private_object_data *po = NULL;
 905
 906         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 907
 908         po = tcore_object_ref_object(o);
 909         if (!po)
 910                 return TCORE_RETURN_EINVAL;
 911
 912         if (po->dedicated_bearer.num_dedicated_bearer > 0)
 913                 memset(&(po->dedicated_bearer), 0, sizeof(struct dedicated_bearer_info));
 914
 915         return TCORE_RETURN_SUCCESS;
 916 }
 917
 918 void tcore_context_cp_service_info(CoreObject *dest, CoreObject *src)
 919 {
 920         struct private_object_data *d_po = NULL;
 921         struct private_object_data *s_po = NULL;
 922
 923         CORE_OBJECT_CHECK(dest, CORE_OBJECT_TYPE_PS_CONTEXT);
 924         CORE_OBJECT_CHECK(src, CORE_OBJECT_TYPE_PS_CONTEXT);
 925
 926         d_po = tcore_object_ref_object(dest);
 927         s_po = tcore_object_ref_object(src);
 928
 929         d_po->state = s_po->state;
 930         d_po->id = s_po->id;
 931
 932         d_po->ip_v6 = g_strdup(s_po->ip_v6);
 933         d_po->dns_primary_v6 = g_strdup(s_po->dns_primary_v6);
 934         d_po->dns_secondary_v6 = g_strdup(s_po->dns_secondary_v6);
 935         d_po->gateway_v6 = g_strdup(s_po->gateway_v6);
 936
 937         memcpy(&(d_po->ip_v4), &(s_po->ip_v4), sizeof(union tcore_ip4_type));
 938         memcpy(&(d_po->dns_primary_v4), &(s_po->dns_primary_v4), sizeof(union tcore_ip4_type));
 939         memcpy(&(d_po->dns_secondary_v4), &(s_po->dns_secondary_v4), sizeof(union tcore_ip4_type));
 940         memcpy(&(d_po->gateway_v4), &(s_po->gateway_v4), sizeof(union tcore_ip4_type));
 941         memcpy(d_po->devname, s_po->devname, sizeof(char) * 16);
 942 }
 943
 944 char *tcore_context_get_ipv4_addr(CoreObject *o)
 945 {
 946         struct private_object_data *po = NULL;
 947
 948         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 949
 950         po = tcore_object_ref_object(o);
 951         if (!po)
 952                 return NULL;
 953
 954         return tcore_util_get_string_by_ip4type(po->ip_v4);
 955 }
 956
 957 char *tcore_context_get_ipv4_dns1(CoreObject *o)
 958 {
 959         struct private_object_data *po = NULL;
 960
 961         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 962
 963         po = tcore_object_ref_object(o);
 964         if (!po)
 965                 return NULL;
 966
 967         return tcore_util_get_string_by_ip4type(po->dns_primary_v4);
 968 }
 969
 970 char *tcore_context_get_ipv4_dns2(CoreObject *o)
 971 {
 972         struct private_object_data *po = NULL;
 973
 974         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 975
 976         po = tcore_object_ref_object(o);
 977         if (!po)
 978                 return NULL;
 979
 980         return tcore_util_get_string_by_ip4type(po->dns_secondary_v4);
 981 }
 982
 983 char *tcore_context_get_ipv4_gw(CoreObject *o)
 984 {
 985         struct private_object_data *po = NULL;
 986
 987         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 988
 989         po = tcore_object_ref_object(o);
 990         if (!po)
 991                 return NULL;
 992
 993         return tcore_util_get_string_by_ip4type(po->gateway_v4);
 994 }
 995
 996 char *tcore_context_get_ipv4_devname(CoreObject *o)
 997 {
 998         struct private_object_data *po = NULL;
 999
1000         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1001
1002         po = tcore_object_ref_object(o);
1003         if (!po)
1004                 return NULL;
1005
1006         if (po->devname[0] == 0)
1007                 return NULL;
1008
1009         return g_strdup(po->devname);
1010 }
1011
1012 char *tcore_context_get_ipv6_addr(CoreObject *o)
1013 {
1014         struct private_object_data *po = NULL;
1015
1016         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1017
1018         po = tcore_object_ref_object(o);
1019         if (!po)
1020                 return NULL;
1021
1022         return g_strdup(po->ip_v6);
1023 }
1024
1025 char *tcore_context_get_ipv6_dns1(CoreObject *o)
1026 {
1027         struct private_object_data *po = NULL;
1028
1029         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1030
1031         po = tcore_object_ref_object(o);
1032         if (!po)
1033                 return NULL;
1034
1035         return g_strdup(po->dns_primary_v6);
1036 }
1037
1038 char *tcore_context_get_ipv6_dns2(CoreObject *o)
1039 {
1040         struct private_object_data *po = NULL;
1041
1042         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1043
1044         po = tcore_object_ref_object(o);
1045         if (!po)
1046                 return NULL;
1047
1048         return g_strdup(po->dns_secondary_v6);
1049 }
1050
1051 char *tcore_context_get_ipv6_gw(CoreObject *o)
1052 {
1053         struct private_object_data *po = NULL;
1054
1055         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1056
1057         po = tcore_object_ref_object(o);
1058         if (!po)
1059                 return NULL;
1060
1061         return g_strdup(po->gateway_v6);
1062 }
1063
1064 pcscf_addr *tcore_context_get_pcscf_ipv4_addr(CoreObject *o)
1065 {
1066         struct private_object_data *po = NULL;
1067         pcscf_addr *pcscf_tmp;
1068
1069         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1070
1071         po = tcore_object_ref_object(o);
1072         if (!po)
1073                 return NULL;
1074
1075         if (!po->pcscf_ipv4)
1076                 return NULL;
1077
1078         pcscf_tmp = g_try_malloc0(sizeof(pcscf_addr));
1079         if (!pcscf_tmp)
1080                 return NULL;
1081
1082         pcscf_tmp->count = po->pcscf_ipv4->count;
1083         if (pcscf_tmp->count > 0) {
1084                 unsigned int i;
1085                 pcscf_tmp->addr = g_try_malloc0(sizeof(char *) * po->pcscf_ipv4->count);
1086                 if (!pcscf_tmp->addr) {
1087                         g_free(pcscf_tmp);
1088                         return NULL;
1089                 }
1090
1091                 for (i = 0; i < po->pcscf_ipv4->count; i++)
1092                         pcscf_tmp->addr[i] = g_strdup(po->pcscf_ipv4->addr[i]);
1093         }
1094
1095         return pcscf_tmp;
1096 }
1097
1098 pcscf_addr *tcore_context_get_pcscf_ipv6_addr(CoreObject *o)
1099 {
1100         struct private_object_data *po = NULL;
1101         pcscf_addr *pcscf_tmp;
1102
1103         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
1104
1105         po = tcore_object_ref_object(o);
1106         if (!po)
1107                 return NULL;
1108
1109         if (!po->pcscf_ipv6)
1110                 return NULL;
1111
1112         pcscf_tmp = g_try_malloc0(sizeof(pcscf_addr));
1113         if (!pcscf_tmp)
1114                 return NULL;
1115
1116         pcscf_tmp->count = po->pcscf_ipv6->count;
1117         if (pcscf_tmp->count > 0) {
1118                 unsigned int i;
1119                 pcscf_tmp->addr = g_try_malloc0(sizeof(char *) * po->pcscf_ipv6->count);
1120                 if (!pcscf_tmp->addr) {
1121                         g_free(pcscf_tmp);
1122                         return NULL;
1123                 }
1124
1125                 for (i = 0; i < po->pcscf_ipv6->count; i++)
1126                         pcscf_tmp->addr[i] = g_strdup(po->pcscf_ipv6->addr[i]);
1127         }
1128
1129         return pcscf_tmp;
1130 }
1131
1132 TReturn tcore_context_set_attach_apn(CoreObject *o, gboolean flag)
1133 {
1134         struct private_object_data *po = NULL;
1135
1136         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
1137
1138         po = tcore_object_ref_object(o);
1139         if (!po)
1140                 return TCORE_RETURN_EINVAL;
1141
1142         po->attach_apn = flag;
1143
1144         return TCORE_RETURN_SUCCESS;
1145 }
1146
1147 gboolean tcore_context_get_attach_apn(CoreObject *o)
1148 {
1149         struct private_object_data *po = NULL;
1150
1151         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
1152
1153         po = tcore_object_ref_object(o);
1154         if (!po)
1155                 return FALSE;
1156
1157         return po->attach_apn;
1158 }