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