src/co_context.c

   1 /*
   2  * libtcore
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co. Ltd. All rights reserved.
   5  * Copyright (c) 2013 Intel Corporation. All rights reserved.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  * http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23
  24 #include <glib.h>
  25
  26 #include "tcore.h"
  27 #include "util.h"
  28 #include "plugin.h"
  29 #include "co_context.h"
  30
  31 #define DEVNAME_LEN_MAX 16
  32
  33 typedef struct {
  34         TcoreContextState state;
  35         guint id;
  36         TcoreContextRole role;
  37
  38         gchar *apn;
  39         gchar *addr;
  40         TcoreContextType type;
  41         TcoreContextDComp d_comp;
  42         TcoreContextHComp h_comp;
  43
  44         gchar *username;
  45         gchar *password;
  46         gchar *dns1;
  47         gchar *dns2;
  48         TcoreContextAuth auth;
  49
  50         TcoreIp4Type ip_v4;
  51         TcoreIp4Type gateway_v4;
  52         TcoreIp4Type dns_primary_v4;
  53         TcoreIp4Type dns_secondary_v4;
  54
  55         /* IPv6 will be supported */
  56
  57         gchar *proxy;
  58         gchar *mmsurl;
  59         gchar *profile_name;
  60         gchar devname[DEVNAME_LEN_MAX];
  61 } PrivateObject;
  62
  63 static void __context_set_ipv4_atoi(guchar *ip4, const gchar *str)
  64 {
  65         gchar *token = NULL;
  66         gchar *temp = NULL;
  67         guint index = 0;
  68
  69         temp = tcore_strdup(str);
  70         token = strtok(temp, ".");
  71         while (token != NULL) {
  72                 ip4[index++] = atoi(token);
  73                 msg("   [%c]", ip4[index-1]);
  74                 token = strtok(NULL, ".");
  75         }
  76         tcore_free(temp);
  77 }
  78
  79 static void __po_free_hook(CoreObject *co)
  80 {
  81         PrivateObject *po = NULL;
  82
  83         po = tcore_object_ref_object(co);
  84         tcore_check_return(po != NULL);
  85
  86         tcore_free(po->apn);
  87         tcore_free(po->addr);
  88         tcore_free(po->username);
  89         tcore_free(po->password);
  90         tcore_free(po->dns1);
  91         tcore_free(po->dns2);
  92         tcore_free(po->proxy);
  93         tcore_free(po->mmsurl);
  94         tcore_free(po->profile_name);
  95         tcore_free(po);
  96
  97         tcore_object_link_object(co, NULL);
  98 }
  99
 100 CoreObject *tcore_context_new(TcorePlugin *p, TcoreHal *hal)
 101 {
 102         CoreObject *co = NULL;
 103         PrivateObject *po = NULL;
 104
 105         tcore_check_return_value_assert(p != NULL, NULL);
 106
 107         co = tcore_object_new(p, hal);
 108         tcore_check_return_value_assert(co != NULL, NULL);
 109
 110         po = tcore_malloc0(sizeof(PrivateObject));
 111         po->type = TCORE_CONTEXT_TYPE_IP;
 112         po->d_comp = TCORE_CONTEXT_D_COMP_OFF;
 113         po->h_comp = TCORE_CONTEXT_H_COMP_OFF;
 114         po->role = TCORE_CONTEXT_ROLE_UNKNOWN;
 115         po->auth = TCORE_CONTEXT_AUTH_NONE;
 116
 117         tcore_object_set_type(co, CORE_OBJECT_TYPE_PS_CONTEXT);
 118         tcore_object_link_object(co, po);
 119         tcore_object_set_free_hook(co, __po_free_hook);
 120
 121         return co;
 122 }
 123
 124 void tcore_context_free(CoreObject *co)
 125 {
 126         CORE_OBJECT_CHECK(co, CORE_OBJECT_TYPE_PS_CONTEXT);
 127         tcore_object_free(co);
 128 }
 129
 130 gboolean tcore_context_set_state(CoreObject *co, TcoreContextState state)
 131 {
 132         PrivateObject *po = NULL;
 133
 134         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 135
 136         dbg("Set State: [%s]",
 137                 ((state == TCORE_CONTEXT_STATE_ACTIVATED) ? "ACTIVATED"
 138                 : (state == TCORE_CONTEXT_STATE_ACTIVATING) ? "ACTIVATING"
 139                 : (state == TCORE_CONTEXT_STATE_DEACTIVATED) ? "DEACTIVATED"
 140                 : "DEACTIVATING"));
 141
 142         po = tcore_object_ref_object(co);
 143         tcore_check_return_value_assert(po != NULL, FALSE);
 144
 145         po->state = state;
 146         return TRUE;
 147 }
 148
 149 gboolean tcore_context_get_state(CoreObject *co, TcoreContextState *state)
 150 {
 151         PrivateObject *po = NULL;
 152
 153         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 154
 155         po = tcore_object_ref_object(co);
 156         tcore_check_return_value_assert(po != NULL, FALSE);
 157
 158         *state = po->state;
 159         return TRUE;
 160 }
 161
 162 gboolean tcore_context_set_id(CoreObject *co, guint id)
 163 {
 164         PrivateObject *po = NULL;
 165
 166         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 167
 168         po = tcore_object_ref_object(co);
 169         tcore_check_return_value_assert(po != NULL, FALSE);
 170
 171         po->id = id;
 172
 173         return TRUE;
 174 }
 175
 176 gboolean tcore_context_get_id(CoreObject *co, guint *id)
 177 {
 178         PrivateObject *po = NULL;
 179
 180         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 181
 182         po = tcore_object_ref_object(co);
 183         tcore_check_return_value_assert(po != NULL, FALSE);
 184
 185         *id = po->id;
 186         return TRUE;
 187 }
 188
 189 gboolean tcore_context_set_apn(CoreObject *co, const gchar *apn)
 190 {
 191         PrivateObject *po = NULL;
 192
 193         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 194
 195         po = tcore_object_ref_object(co);
 196         tcore_check_return_value_assert(po != NULL, FALSE);
 197
 198         tcore_free(po->apn);
 199         po->apn = tcore_strdup(apn);
 200         return TRUE;
 201 }
 202
 203 gboolean tcore_context_get_apn(CoreObject *co, gchar **apn)
 204 {
 205         PrivateObject *po = NULL;
 206
 207         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 208         po = tcore_object_ref_object(co);
 209         tcore_check_return_value_assert(po != NULL, FALSE);
 210         *apn =  tcore_strdup(po->apn);
 211         return TRUE;
 212 }
 213
 214 gboolean tcore_context_set_role(CoreObject *co, TcoreContextRole role)
 215 {
 216         PrivateObject *po = NULL;
 217
 218         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 219
 220         po = tcore_object_ref_object(co);
 221         tcore_check_return_value_assert(po != NULL, FALSE);
 222
 223         po->role = role;
 224         return TRUE;
 225 }
 226
 227 gboolean tcore_context_get_role(CoreObject *co, TcoreContextRole *role)
 228 {
 229         PrivateObject *po = NULL;
 230
 231         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 232
 233         po = tcore_object_ref_object(co);
 234         tcore_check_return_value_assert(po != NULL, FALSE);
 235
 236         *role = po->role;
 237         return TRUE;
 238 }
 239
 240 gboolean tcore_context_set_type(CoreObject *co, TcoreContextType type)
 241 {
 242         PrivateObject *po = NULL;
 243
 244         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 245
 246         po = tcore_object_ref_object(co);
 247         tcore_check_return_value_assert(po != NULL, FALSE);
 248
 249         po->type = type;
 250         return TRUE;
 251 }
 252
 253 gboolean tcore_context_get_type(CoreObject *co, TcoreContextType *type)
 254 {
 255         PrivateObject *po = NULL;
 256
 257         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 258
 259         po = tcore_object_ref_object(co);
 260         tcore_check_return_value_assert(po != NULL, FALSE);
 261
 262         *type = po->type;
 263         return TRUE;
 264 }
 265
 266 gboolean tcore_context_set_data_compression(CoreObject *co, TcoreContextDComp comp)
 267 {
 268         PrivateObject *po = NULL;
 269
 270         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 271
 272         po = tcore_object_ref_object(co);
 273         tcore_check_return_value_assert(po != NULL, FALSE);
 274
 275         po->d_comp = comp;
 276         return TRUE;
 277 }
 278
 279 gboolean tcore_context_get_data_compression(CoreObject *co, TcoreContextDComp *comp)
 280 {
 281         PrivateObject *po = NULL;
 282
 283         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 284
 285         po = tcore_object_ref_object(co);
 286         tcore_check_return_value_assert(po != NULL, FALSE);
 287
 288         *comp = po->d_comp;
 289         return TRUE;
 290 }
 291
 292 gboolean tcore_context_set_header_compression(CoreObject *co, TcoreContextHComp comp)
 293 {
 294         PrivateObject *po = NULL;
 295
 296         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 297
 298         po = tcore_object_ref_object(co);
 299         tcore_check_return_value_assert(po != NULL, FALSE);
 300
 301         po->h_comp = comp;
 302         return TRUE;
 303 }
 304
 305 gboolean tcore_context_get_header_compression(CoreObject *co, TcoreContextHComp *comp)
 306 {
 307         PrivateObject *po = NULL;
 308
 309         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 310
 311         po = tcore_object_ref_object(co);
 312         tcore_check_return_value_assert(po != NULL, FALSE);
 313
 314         *comp = po->h_comp;
 315         return TRUE;
 316 }
 317
 318 gboolean tcore_context_set_username(CoreObject *co, const gchar *username)
 319 {
 320         PrivateObject *po = NULL;
 321
 322         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 323
 324         po = tcore_object_ref_object(co);
 325         tcore_check_return_value_assert(po != NULL, FALSE);
 326
 327         tcore_free(po->username);
 328         po->username = tcore_strdup(username);
 329         return TRUE;
 330 }
 331
 332 gboolean tcore_context_get_username(CoreObject *co, gchar **username)
 333 {
 334         PrivateObject *po = NULL;
 335
 336         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 337
 338         po = tcore_object_ref_object(co);
 339         tcore_check_return_value_assert(po != NULL, FALSE);
 340
 341         *username = tcore_strdup(po->username);
 342         return TRUE;
 343 }
 344
 345 gboolean tcore_context_set_password(CoreObject *co, const gchar *password)
 346 {
 347         PrivateObject *po = NULL;
 348
 349         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 350
 351         po = tcore_object_ref_object(co);
 352         tcore_check_return_value_assert(po != NULL, FALSE);
 353
 354         tcore_free(po->password);
 355         po->password = tcore_strdup(password);
 356         return TRUE;
 357 }
 358
 359 gboolean tcore_context_get_password(CoreObject *co, gchar **password)
 360 {
 361         PrivateObject *po = NULL;
 362
 363         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 364
 365         po = tcore_object_ref_object(co);
 366         tcore_check_return_value_assert(po != NULL, FALSE);
 367
 368         *password =  tcore_strdup(po->password);
 369         return TRUE;
 370 }
 371
 372 gboolean tcore_context_set_auth(CoreObject *co, TcoreContextAuth auth)
 373 {
 374         PrivateObject *po = NULL;
 375
 376         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 377
 378         po = tcore_object_ref_object(co);
 379         tcore_check_return_value_assert(po != NULL, FALSE);
 380
 381         po->auth = auth;
 382         return TRUE;
 383 }
 384
 385 gboolean tcore_context_get_auth(CoreObject *co, TcoreContextAuth *auth)
 386 {
 387         PrivateObject *po = NULL;
 388
 389         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 390
 391         po = tcore_object_ref_object(co);
 392         tcore_check_return_value_assert(po != NULL, FALSE);
 393
 394         *auth = po->auth;
 395         return TRUE;
 396 }
 397
 398 gboolean tcore_context_set_proxy(CoreObject *co, const gchar *proxy)
 399 {
 400         PrivateObject *po = NULL;
 401
 402         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 403
 404         po = tcore_object_ref_object(co);
 405         tcore_check_return_value_assert(po != NULL, FALSE);
 406
 407         tcore_free(po->proxy);
 408         po->proxy = tcore_strdup(proxy);
 409         return TRUE;
 410 }
 411
 412 gboolean tcore_context_get_proxy(CoreObject *co, gchar **proxy)
 413 {
 414         PrivateObject *po = NULL;
 415
 416         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 417
 418         po = tcore_object_ref_object(co);
 419         tcore_check_return_value_assert(po != NULL, FALSE);
 420
 421         *proxy = tcore_strdup(po->proxy);
 422         return TRUE;
 423 }
 424
 425 gboolean tcore_context_set_mmsurl(CoreObject *co, const gchar *mmsurl)
 426 {
 427         PrivateObject *po = NULL;
 428
 429         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 430
 431         po = tcore_object_ref_object(co);
 432         tcore_check_return_value_assert(po != NULL, FALSE);
 433
 434         tcore_free(po->mmsurl);
 435         po->mmsurl = tcore_strdup(mmsurl);
 436         return TRUE;
 437 }
 438
 439 gboolean tcore_context_get_mmsurl(CoreObject *co, gchar **mmsurl)
 440 {
 441         PrivateObject *po = NULL;
 442
 443         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 444
 445         po = tcore_object_ref_object(co);
 446         tcore_check_return_value_assert(po != NULL, FALSE);
 447
 448         *mmsurl = tcore_strdup(po->mmsurl);
 449         return TRUE;
 450 }
 451
 452 gboolean tcore_context_set_profile_name(CoreObject *co, const gchar *profile_name)
 453 {
 454         PrivateObject *po = NULL;
 455
 456         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 457
 458         po = tcore_object_ref_object(co);
 459         tcore_check_return_value_assert(po != NULL, FALSE);
 460
 461         tcore_free(po->profile_name);
 462         po->profile_name = tcore_strdup(profile_name);
 463         return TRUE;
 464 }
 465
 466 gboolean tcore_context_get_profile_name(CoreObject *co, gchar **profile_name)
 467 {
 468         PrivateObject *po = NULL;
 469
 470         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 471
 472         po = tcore_object_ref_object(co);
 473         tcore_check_return_value_assert(po != NULL, FALSE);
 474
 475         *profile_name =  tcore_strdup(po->profile_name);
 476         return TRUE;
 477 }
 478
 479 gboolean tcore_context_set_devinfo(CoreObject *co, TcorePsPdpIpConf *devinfo)
 480 {
 481         PrivateObject *po = NULL;
 482
 483         dbg("Setup device information");
 484
 485         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 486
 487         po = tcore_object_ref_object(co);
 488         tcore_check_return_value_assert(po != NULL, FALSE);
 489         tcore_check_return_value_assert(devinfo != NULL, FALSE);
 490
 491         memcpy(&(po->ip_v4), devinfo->ip_address, sizeof(TcoreIp4Type));
 492         memcpy(&(po->dns_primary_v4), devinfo->primary_dns, sizeof(TcoreIp4Type));
 493         memcpy(&(po->dns_secondary_v4), devinfo->secondary_dns, sizeof(TcoreIp4Type));
 494         memcpy(&(po->gateway_v4), devinfo->gateway, sizeof(TcoreIp4Type));
 495         memcpy(po->devname, devinfo->devname, sizeof(gchar) * 16);
 496
 497         msg("   IP Address: [0x%x]", po->ip_v4);
 498         msg("   DNS - Primary: [0x%x] Secondary: [0x%x]", po->dns_primary_v4, po->dns_secondary_v4);
 499         msg("   Gateway: [0x%x]", po->gateway_v4);
 500         msg("   Device Name: [%s]", po->devname);
 501
 502         return TRUE;
 503 }
 504
 505 gboolean tcore_context_reset_devinfo(CoreObject *co)
 506 {
 507         PrivateObject *po = NULL;
 508
 509         dbg("Reset device information");
 510
 511         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 512
 513         po = tcore_object_ref_object(co);
 514         tcore_check_return_value_assert(po != NULL, FALSE);
 515
 516         memset(&(po->ip_v4), 0, sizeof(TcoreIp4Type));
 517         memset(&(po->dns_primary_v4), 0, sizeof(TcoreIp4Type));
 518         memset(&(po->dns_secondary_v4), 0, sizeof(TcoreIp4Type));
 519         memset(&(po->gateway_v4), 0, sizeof(TcoreIp4Type));
 520         memset(po->devname, 0, sizeof(gchar) * 16);
 521
 522         return TRUE;
 523 }
 524
 525 void tcore_context_cp_service_info(CoreObject *dest, CoreObject *src)
 526 {
 527         PrivateObject *d_po = NULL;
 528         PrivateObject *s_po = NULL;
 529
 530         CORE_OBJECT_CHECK(dest, CORE_OBJECT_TYPE_PS_CONTEXT);
 531         CORE_OBJECT_CHECK(src, CORE_OBJECT_TYPE_PS_CONTEXT);
 532
 533         d_po = tcore_object_ref_object(dest);
 534         s_po = tcore_object_ref_object(src);
 535
 536         d_po->state = s_po->state;
 537         d_po->id = s_po->id;
 538         memcpy(&(d_po->ip_v4), &(s_po->ip_v4), sizeof(TcoreIp4Type));
 539         memcpy(&(d_po->dns_primary_v4), &(s_po->dns_primary_v4), sizeof(TcoreIp4Type));
 540         memcpy(&(d_po->dns_secondary_v4), &(s_po->dns_secondary_v4), sizeof(TcoreIp4Type));
 541         memcpy(&(d_po->gateway_v4), &(s_po->gateway_v4), sizeof(TcoreIp4Type));
 542         memcpy(d_po->devname, s_po->devname, sizeof(gchar) * 16);
 543
 544         return;
 545 }
 546
 547 gboolean tcore_context_set_ipv4_addr(CoreObject *co, const gchar *addr)
 548 {
 549         PrivateObject *po = NULL;
 550
 551         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 552
 553         po = tcore_object_ref_object(co);
 554         tcore_check_return_value_assert(po != NULL, FALSE);
 555
 556         if (po->addr) {
 557                 tcore_free(po->addr);
 558                 po->addr = NULL;
 559         }
 560
 561         if (addr) {
 562                 po->addr = tcore_strdup(addr);
 563                 __context_set_ipv4_atoi(po->ip_v4.s, addr);
 564                 dbg("IP Address: [%s]", addr);
 565         }
 566
 567         return TRUE;
 568 }
 569
 570 gboolean tcore_context_get_ipv4_addr(CoreObject *co, gchar **ip)
 571 {
 572         PrivateObject *po = NULL;
 573
 574         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 575
 576         po = tcore_object_ref_object(co);
 577         tcore_check_return_value_assert(po != NULL, FALSE);
 578
 579         *ip =  tcore_util_get_string_by_ip4type(po->ip_v4);
 580         return TRUE;
 581 }
 582
 583 gboolean tcore_context_set_ipv4_dns(CoreObject *co, const gchar *dns1, const gchar *dns2)
 584 {
 585         PrivateObject *po = NULL;
 586
 587         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 588
 589         po = tcore_object_ref_object(co);
 590         tcore_check_return_value_assert(po != NULL, FALSE);
 591
 592         tcore_free(po->dns1);
 593         po->dns1 = NULL;
 594
 595         tcore_free(po->dns2);
 596         po->dns2 = NULL;
 597
 598         if (dns1) {
 599                 po->dns1 = tcore_strdup(dns1);
 600                 __context_set_ipv4_atoi(po->dns_primary_v4.s, dns1);
 601         }
 602
 603         if (dns2) {
 604                 po->dns2 = tcore_strdup(dns2);
 605                 __context_set_ipv4_atoi(po->dns_secondary_v4.s, dns2);
 606         }
 607
 608         return TRUE;
 609 }
 610
 611 gboolean tcore_context_get_ipv4_dns1(CoreObject *co, gchar **ip)
 612 {
 613         PrivateObject *po = NULL;
 614
 615         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 616
 617         po = tcore_object_ref_object(co);
 618         tcore_check_return_value_assert(po != NULL, FALSE);
 619
 620         *ip = tcore_util_get_string_by_ip4type(po->dns_primary_v4);
 621         return TRUE;
 622 }
 623
 624 gboolean tcore_context_get_ipv4_dns2(CoreObject *co, gchar **ip)
 625 {
 626         PrivateObject *po = NULL;
 627
 628         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 629
 630         po = tcore_object_ref_object(co);
 631         tcore_check_return_value_assert(po != NULL, FALSE);
 632
 633         *ip = tcore_util_get_string_by_ip4type(po->dns_secondary_v4);
 634         return TRUE;
 635 }
 636
 637 gboolean tcore_context_get_ipv4_gw(CoreObject *co, gchar **ip)
 638 {
 639         PrivateObject *po = NULL;
 640
 641         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 642
 643         po = tcore_object_ref_object(co);
 644         tcore_check_return_value_assert(po != NULL, FALSE);
 645
 646         *ip =  tcore_util_get_string_by_ip4type(po->gateway_v4);
 647         return TRUE;
 648 }
 649
 650 gboolean tcore_context_set_ipv4_devname(CoreObject *co, const gchar *name)
 651 {
 652         PrivateObject *po = NULL;
 653
 654         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 655
 656         po = tcore_object_ref_object(co);
 657         tcore_check_return_value_assert(po != NULL, FALSE);
 658
 659         if (name) {
 660                 snprintf(po->devname, DEVNAME_LEN_MAX, "%s", name);
 661         }
 662
 663         return TRUE;
 664 }
 665
 666 gboolean tcore_context_get_ipv4_devname(CoreObject *co, gchar **dev_name)
 667 {
 668         PrivateObject *po = NULL;
 669
 670         CORE_OBJECT_CHECK_RETURN(co, CORE_OBJECT_TYPE_PS_CONTEXT, FALSE);
 671
 672         po = tcore_object_ref_object(co);
 673         tcore_check_return_value_assert(po != NULL, FALSE);
 674
 675         if (po->devname[0] == 0)
 676                 return TRUE;
 677
 678         *dev_name = tcore_strdup(po->devname);
 679         return TRUE;
 680 }