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 int id;
  36         enum co_context_role role;
  37
  38         char *apn;
  39         char *addr;
  40         enum co_context_type type;
  41         enum co_context_d_comp d_comp;
  42         enum co_context_h_comp h_comp;
  43
  44         char *username;
  45         char *password;
  46         char *dns1;
  47         char *dns2;
  48         enum co_context_auth auth;
  49
  50         union tcore_ip4_type ip_v4;
  51         union tcore_ip4_type gateway_v4;
  52         union tcore_ip4_type dns_primary_v4;
  53         union tcore_ip4_type dns_secondary_v4;
  54
  55         /*IPv6 will be supported*/
  56
  57         char *proxy;
  58         char *mmsurl;
  59         char *profile_name;
  60         char devname[16];
  61 };
  62
  63 static void _free_hook(CoreObject *o)
  64 {
  65         struct private_object_data *po = NULL;
  66
  67         po = tcore_object_ref_object(o);
  68         if (po) {
  69                 g_free(po);
  70                 tcore_object_link_object(o, NULL);
  71         }
  72 }
  73
  74 CoreObject *tcore_context_new(TcorePlugin *p, const char *name, TcoreHal *hal)
  75 {
  76         CoreObject *o = NULL;
  77         struct private_object_data *po = NULL;
  78
  79         if (!p)
  80                 return NULL;
  81
  82         o = tcore_object_new(p, name, hal);
  83         if (!o)
  84                 return NULL;
  85
  86         po = calloc(sizeof(struct private_object_data), 1);
  87         if (!po) {
  88                 tcore_object_free(o);
  89                 return NULL;
  90         }
  91
  92         po->type = CONTEXT_TYPE_IP;
  93         po->d_comp = CONTEXT_D_COMP_OFF;
  94         po->h_comp = CONTEXT_H_COMP_OFF;
  95         po->role = CONTEXT_ROLE_UNKNOWN;
  96         po->auth = CONTEXT_AUTH_NONE;
  97
  98         tcore_object_set_type(o, CORE_OBJECT_TYPE_PS_CONTEXT);
  99         tcore_object_link_object(o, po);
 100         tcore_object_set_free_hook(o, _free_hook);
 101
 102         return o;
 103 }
 104
 105 void tcore_context_free(CoreObject *o)
 106 {
 107         struct private_object_data *po = NULL;
 108
 109         CORE_OBJECT_CHECK(o, CORE_OBJECT_TYPE_PS_CONTEXT);
 110
 111         po = tcore_object_ref_object(o);
 112         if (!po)
 113                 return;
 114
 115         g_free(po);
 116         tcore_object_link_object(o, NULL);
 117         tcore_object_free(o);
 118 }
 119
 120 TReturn tcore_context_set_state(CoreObject *o, enum co_context_state state)
 121 {
 122         struct private_object_data *po = NULL;
 123
 124         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 125
 126         po = tcore_object_ref_object(o);
 127         if (!po)
 128                 return TCORE_RETURN_EINVAL;
 129
 130         po->state = state;
 131
 132         return TCORE_RETURN_SUCCESS;
 133 }
 134
 135 enum co_context_state    tcore_context_get_state(CoreObject *o)
 136 {
 137         struct private_object_data *po = NULL;
 138
 139         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 140
 141         po = tcore_object_ref_object(o);
 142         if (!po)
 143                 return 0;
 144
 145         return po->state;
 146 }
 147
 148 TReturn tcore_context_set_id(CoreObject *o, unsigned int id)
 149 {
 150         struct private_object_data *po = NULL;
 151
 152         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 153
 154         po = tcore_object_ref_object(o);
 155         if (!po)
 156                 return TCORE_RETURN_EINVAL;
 157
 158         po->id = id;
 159
 160         return TCORE_RETURN_SUCCESS;
 161 }
 162
 163 unsigned int tcore_context_get_id(CoreObject *o)
 164 {
 165         struct private_object_data *po = NULL;
 166
 167         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 168
 169         po = tcore_object_ref_object(o);
 170         if (!po)
 171                 return 0;
 172
 173         return po->id;
 174 }
 175
 176 TReturn tcore_context_set_apn(CoreObject *o, const char *apn)
 177 {
 178         struct private_object_data *po = NULL;
 179
 180         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 181
 182         po = tcore_object_ref_object(o);
 183         if (!po)
 184                 return FALSE;
 185
 186         if (po->apn) {
 187                 free(po->apn);
 188                 po->apn = NULL;
 189         }
 190
 191         if (apn) {
 192                 po->apn = g_strdup(apn);
 193         }
 194
 195         return TCORE_RETURN_SUCCESS;
 196 }
 197
 198 char *tcore_context_get_apn(CoreObject *o)
 199 {
 200         struct private_object_data *po = NULL;
 201
 202         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 203
 204         po = tcore_object_ref_object(o);
 205         if (!po)
 206                 return NULL;
 207
 208         if (!po->apn)
 209                 return NULL;
 210
 211         return g_strdup(po->apn);
 212 }
 213
 214 TReturn tcore_context_set_address(CoreObject *o, const char *addr)
 215 {
 216         struct private_object_data *po = NULL;
 217
 218         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 219
 220         po = tcore_object_ref_object(o);
 221         if (!po)
 222                 return TCORE_RETURN_EINVAL;
 223
 224         if (po->addr) {
 225                 free(po->addr);
 226                 po->addr = NULL;
 227         }
 228
 229         if (addr) {
 230                 po->addr = g_strdup(addr);
 231         }
 232
 233         return TCORE_RETURN_SUCCESS;
 234 }
 235
 236 char *tcore_context_get_address(CoreObject *o)
 237 {
 238         struct private_object_data *po = NULL;
 239
 240         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 241
 242         po = tcore_object_ref_object(o);
 243         if (!po)
 244                 return NULL;
 245
 246         if (!po->addr)
 247                 return NULL;
 248
 249         return g_strdup(po->addr);
 250 }
 251
 252 TReturn tcore_context_set_role(CoreObject *o, enum co_context_role role)
 253 {
 254         struct private_object_data *po = NULL;
 255
 256         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 257
 258         po = tcore_object_ref_object(o);
 259         if (!po)
 260                 return TCORE_RETURN_EINVAL;
 261
 262         po->role = role;
 263
 264         return TCORE_RETURN_SUCCESS;
 265 }
 266
 267 enum co_context_role tcore_context_get_role(CoreObject *o)
 268 {
 269         struct private_object_data *po = NULL;
 270
 271         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 272
 273         po = tcore_object_ref_object(o);
 274         if (!po)
 275                 return 0;
 276
 277         return po->role;
 278 }
 279
 280 TReturn tcore_context_set_type(CoreObject *o, enum co_context_type type)
 281 {
 282         struct private_object_data *po = NULL;
 283
 284         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 285
 286         po = tcore_object_ref_object(o);
 287         if (!po)
 288                 return TCORE_RETURN_EINVAL;
 289
 290         po->type = type;
 291
 292         return TCORE_RETURN_SUCCESS;
 293 }
 294
 295 enum co_context_type tcore_context_get_type(CoreObject *o)
 296 {
 297         struct private_object_data *po = NULL;
 298
 299         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 300
 301         po = tcore_object_ref_object(o);
 302         if (!po)
 303                 return 0;
 304
 305         return po->type;
 306 }
 307
 308 TReturn tcore_context_set_data_compression(CoreObject *o, enum co_context_d_comp comp)
 309 {
 310         struct private_object_data *po = NULL;
 311
 312         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 313
 314         po = tcore_object_ref_object(o);
 315         if (!po)
 316                 return TCORE_RETURN_EINVAL;
 317
 318         po->d_comp = comp;
 319
 320         return TCORE_RETURN_SUCCESS;
 321 }
 322
 323 enum co_context_d_comp tcore_context_get_data_compression(CoreObject *o)
 324 {
 325         struct private_object_data *po = NULL;
 326
 327         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 328
 329         po = tcore_object_ref_object(o);
 330         if (!po)
 331                 return 0;
 332
 333         return po->d_comp;
 334 }
 335
 336 TReturn tcore_context_set_header_compression(CoreObject *o, enum co_context_h_comp comp)
 337 {
 338         struct private_object_data *po = NULL;
 339
 340         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 341
 342         po = tcore_object_ref_object(o);
 343         if (!po)
 344                 return TCORE_RETURN_EINVAL;
 345
 346         po->h_comp = comp;
 347
 348         return TCORE_RETURN_SUCCESS;
 349 }
 350
 351 enum co_context_h_comp tcore_context_get_header_compression(CoreObject *o)
 352 {
 353         struct private_object_data *po = NULL;
 354
 355         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 356
 357         po = tcore_object_ref_object(o);
 358         if (!po)
 359                 return 0;
 360
 361         return po->h_comp;
 362 }
 363
 364 TReturn tcore_context_set_username(CoreObject *o, const char *username)
 365 {
 366         struct private_object_data *po = NULL;
 367
 368         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 369
 370         po = tcore_object_ref_object(o);
 371         if (!po)
 372                 return TCORE_RETURN_EINVAL;
 373
 374         if (po->username) {
 375                 free(po->username);
 376                 po->username = NULL;
 377         }
 378
 379         if (username) {
 380                 po->username = g_strdup(username);
 381         }
 382
 383         return TCORE_RETURN_SUCCESS;
 384 }
 385
 386 char *tcore_context_get_username(CoreObject *o)
 387 {
 388         struct private_object_data *po = NULL;
 389
 390         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 391
 392         po = tcore_object_ref_object(o);
 393         if (!po)
 394                 return NULL;
 395
 396         if (!po->username)
 397                 return NULL;
 398
 399         return g_strdup(po->username);
 400 }
 401
 402 TReturn tcore_context_set_password(CoreObject *o, const char *password)
 403 {
 404         struct private_object_data *po = NULL;
 405
 406         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 407
 408         po = tcore_object_ref_object(o);
 409         if (!po)
 410                 return TCORE_RETURN_EINVAL;
 411
 412         if (po->password) {
 413                 free(po->password);
 414                 po->password = NULL;
 415         }
 416
 417         if (password) {
 418                 po->password = g_strdup(password);
 419         }
 420
 421         return TCORE_RETURN_SUCCESS;
 422 }
 423
 424 char *tcore_context_get_password(CoreObject *o)
 425 {
 426         struct private_object_data *po = NULL;
 427
 428         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 429
 430         po = tcore_object_ref_object(o);
 431         if (!po)
 432                 return NULL;
 433
 434         if (!po->password)
 435                 return NULL;
 436
 437         return g_strdup(po->password);
 438 }
 439
 440 TReturn tcore_context_set_dns1(CoreObject *o, const char *dns)
 441 {
 442         struct private_object_data *po = NULL;
 443
 444         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 445
 446         po = tcore_object_ref_object(o);
 447         if (!po)
 448                 return TCORE_RETURN_EINVAL;
 449
 450         if (po->dns1) {
 451                 free(po->dns1);
 452                 po->dns1 = NULL;
 453         }
 454
 455         if (dns) {
 456                 po->dns1 = g_strdup(dns);
 457         }
 458
 459         return TCORE_RETURN_SUCCESS;
 460 }
 461
 462 char *tcore_context_get_dns1(CoreObject *o)
 463 {
 464         struct private_object_data *po = NULL;
 465
 466         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 467
 468         po = tcore_object_ref_object(o);
 469         if (!po)
 470                 return NULL;
 471
 472         if (!po->dns1)
 473                 return NULL;
 474
 475         return g_strdup(po->dns1);
 476 }
 477
 478 TReturn tcore_context_set_dns2(CoreObject *o, const char *dns)
 479 {
 480         struct private_object_data *po = NULL;
 481
 482         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 483
 484         po = tcore_object_ref_object(o);
 485         if (!po)
 486                 return TCORE_RETURN_EINVAL;
 487
 488         if (po->dns2) {
 489                 free(po->dns2);
 490                 po->dns2 = NULL;
 491         }
 492
 493         if (dns) {
 494                 po->dns2 = g_strdup(dns);
 495         }
 496
 497         return TCORE_RETURN_SUCCESS;
 498 }
 499
 500 char *tcore_context_get_dns2(CoreObject *o)
 501 {
 502         struct private_object_data *po = NULL;
 503
 504         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 505
 506         po = tcore_object_ref_object(o);
 507         if (!po)
 508                 return NULL;
 509
 510         if (!po->dns2)
 511                 return NULL;
 512
 513         return g_strdup(po->dns2);
 514 }
 515
 516 TReturn tcore_context_set_auth(CoreObject *o, enum co_context_auth auth)
 517 {
 518         struct private_object_data *po = NULL;
 519
 520         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 521
 522         po = tcore_object_ref_object(o);
 523         if (!po)
 524                 return TCORE_RETURN_EINVAL;
 525
 526         po->auth = auth;
 527
 528         return TCORE_RETURN_SUCCESS;
 529 }
 530
 531 enum co_context_auth tcore_context_get_auth(CoreObject *o)
 532 {
 533         struct private_object_data *po = NULL;
 534
 535         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, 0);
 536
 537         po = tcore_object_ref_object(o);
 538         if (!po)
 539                 return 0;
 540
 541         return po->auth;
 542 }
 543
 544 TReturn tcore_context_set_proxy(CoreObject *o, const char *proxy)
 545 {
 546         struct private_object_data *po = NULL;
 547
 548         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 549
 550         po = tcore_object_ref_object(o);
 551         if (!po)
 552                 return FALSE;
 553
 554         if (po->proxy) {
 555                 free(po->proxy);
 556                 po->apn = NULL;
 557         }
 558
 559         if (proxy) {
 560                 po->proxy = g_strdup(proxy);
 561         }
 562
 563         return TCORE_RETURN_SUCCESS;
 564 }
 565
 566 char *tcore_context_get_proxy(CoreObject *o)
 567 {
 568         struct private_object_data *po = NULL;
 569
 570         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 571
 572         po = tcore_object_ref_object(o);
 573         if (!po)
 574                 return NULL;
 575
 576         if (!po->proxy)
 577                 return NULL;
 578
 579         return g_strdup(po->proxy);
 580 }
 581
 582 TReturn tcore_context_set_mmsurl(CoreObject *o, const char *mmsurl)
 583 {
 584         struct private_object_data *po = NULL;
 585
 586         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 587
 588         po = tcore_object_ref_object(o);
 589         if (!po)
 590                 return FALSE;
 591
 592         if (po->mmsurl) {
 593                 free(po->mmsurl);
 594                 po->mmsurl = NULL;
 595         }
 596
 597         if (mmsurl) {
 598                 po->mmsurl = g_strdup(mmsurl);
 599         }
 600
 601         return TCORE_RETURN_SUCCESS;
 602 }
 603
 604 char *tcore_context_get_mmsurl(CoreObject *o)
 605 {
 606         struct private_object_data *po = NULL;
 607
 608         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 609
 610         po = tcore_object_ref_object(o);
 611         if (!po)
 612                 return NULL;
 613
 614         if (!po->mmsurl)
 615                 return NULL;
 616
 617         return g_strdup(po->mmsurl);
 618 }
 619
 620 TReturn tcore_context_set_profile_name(CoreObject *o, const char *profile_name)
 621 {
 622         struct private_object_data *po = NULL;
 623
 624         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 625
 626         po = tcore_object_ref_object(o);
 627         if (!po)
 628                 return FALSE;
 629
 630         if (po->profile_name) {
 631                 free(po->profile_name);
 632                 po->profile_name = NULL;
 633         }
 634
 635         if (profile_name) {
 636                 po->profile_name = g_strdup(profile_name);
 637         }
 638
 639         return TCORE_RETURN_SUCCESS;
 640 }
 641
 642 char *tcore_context_get_profile_name(CoreObject *o)
 643 {
 644         struct private_object_data *po = NULL;
 645
 646         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 647
 648         po = tcore_object_ref_object(o);
 649         if (!po)
 650                 return NULL;
 651
 652         if (!po->profile_name)
 653                 return NULL;
 654
 655         return g_strdup(po->profile_name);
 656 }
 657
 658 TReturn tcore_context_set_devinfo(CoreObject *o, struct tnoti_ps_pdp_ipconfiguration *devinfo)
 659 {
 660         struct private_object_data *po = NULL;
 661
 662         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 663
 664         po = tcore_object_ref_object(o);
 665         if (!po)
 666                 return FALSE;
 667         if (!devinfo)
 668                 return FALSE;
 669
 670         memcpy(&(po->ip_v4), devinfo->ip_address, sizeof(union tcore_ip4_type));
 671         memcpy(&(po->dns_primary_v4), devinfo->primary_dns, sizeof(union tcore_ip4_type));
 672         memcpy(&(po->dns_secondary_v4), devinfo->secondary_dns, sizeof(union tcore_ip4_type));
 673         memcpy(&(po->gateway_v4), devinfo->gateway, sizeof(union tcore_ip4_type));
 674         memcpy(po->devname, devinfo->devname, sizeof(char) * 16);
 675
 676         return TCORE_RETURN_SUCCESS;
 677 }
 678
 679 TReturn tcore_context_reset_devinfo(CoreObject *o)
 680 {
 681         struct private_object_data *po = NULL;
 682
 683         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, TCORE_RETURN_EINVAL);
 684
 685         po = tcore_object_ref_object(o);
 686         if (!po)
 687                 return FALSE;
 688
 689         memset(&(po->ip_v4), 0, sizeof(union tcore_ip4_type));
 690         memset(&(po->dns_primary_v4), 0, sizeof(union tcore_ip4_type));
 691         memset(&(po->dns_secondary_v4), 0, sizeof(union tcore_ip4_type));
 692         memset(&(po->gateway_v4), 0, sizeof(union tcore_ip4_type));
 693         memset(po->devname, 0, sizeof(char) * 16);
 694
 695         return TCORE_RETURN_SUCCESS;
 696 }
 697
 698 void tcore_context_cp_service_info(CoreObject *dest, CoreObject *src)
 699 {
 700         struct private_object_data *d_po = NULL;
 701         struct private_object_data *s_po = NULL;
 702
 703         CORE_OBJECT_CHECK(dest, CORE_OBJECT_TYPE_PS_CONTEXT);
 704         CORE_OBJECT_CHECK(src, CORE_OBJECT_TYPE_PS_CONTEXT);
 705
 706         d_po = tcore_object_ref_object(dest);
 707         s_po = tcore_object_ref_object(src);
 708
 709         d_po->state = s_po->state;
 710         d_po->id = s_po->id;
 711         memcpy(&(d_po->ip_v4), &(s_po->ip_v4), sizeof(union tcore_ip4_type));
 712         memcpy(&(d_po->dns_primary_v4), &(s_po->dns_primary_v4), sizeof(union tcore_ip4_type));
 713         memcpy(&(d_po->dns_secondary_v4), &(s_po->dns_secondary_v4), sizeof(union tcore_ip4_type));
 714         memcpy(&(d_po->gateway_v4), &(s_po->gateway_v4), sizeof(union tcore_ip4_type));
 715         memcpy(d_po->devname, s_po->devname, sizeof(char) * 16);
 716
 717         return;
 718 }
 719
 720 char* tcore_context_get_ipv4_addr(CoreObject *o)
 721 {
 722         struct private_object_data *po = NULL;
 723
 724         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 725
 726         po = tcore_object_ref_object(o);
 727         if (!po)
 728                 return NULL;
 729
 730         return tcore_util_get_string_by_ip4type(po->ip_v4);
 731 }
 732
 733 char* tcore_context_get_ipv4_dns1(CoreObject *o)
 734 {
 735         struct private_object_data *po = NULL;
 736
 737         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 738
 739         po = tcore_object_ref_object(o);
 740         if (!po)
 741                 return NULL;
 742
 743         return tcore_util_get_string_by_ip4type(po->dns_primary_v4);
 744 }
 745
 746 char* tcore_context_get_ipv4_dns2(CoreObject *o)
 747 {
 748         struct private_object_data *po = NULL;
 749
 750         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 751
 752         po = tcore_object_ref_object(o);
 753         if (!po)
 754                 return NULL;
 755
 756         return tcore_util_get_string_by_ip4type(po->dns_secondary_v4);
 757 }
 758
 759 char* tcore_context_get_ipv4_gw(CoreObject *o)
 760 {
 761         struct private_object_data *po = NULL;
 762
 763         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 764
 765         po = tcore_object_ref_object(o);
 766         if (!po)
 767                 return NULL;
 768
 769         return tcore_util_get_string_by_ip4type(po->gateway_v4);
 770 }
 771
 772 char* tcore_context_get_ipv4_devname(CoreObject *o)
 773 {
 774         struct private_object_data *po = NULL;
 775
 776         CORE_OBJECT_CHECK_RETURN(o, CORE_OBJECT_TYPE_PS_CONTEXT, NULL);
 777
 778         po = tcore_object_ref_object(o);
 779         if (!po)
 780                 return NULL;
 781
 782         if (po->devname[0] == 0)
 783                 return NULL;
 784
 785         return g_strdup(po->devname);
 786 }