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