src/client/security-server-client.c

   1 /*
   2  * security-server
   3  *
   4  *  Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd All Rights Reserved
   5  *
   6  *  Contact: Bumjin Im <bj.im@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
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <sys/types.h>
  25 #include <sys/stat.h>
  26 #include <errno.h>
  27 #include <unistd.h>
  28 #include <string.h>
  29 #include <sys/smack.h>
  30 #include <fcntl.h>
  31 #include <sys/socket.h>
  32 #include <sys/un.h>
  33 #include <sys/poll.h>
  34
  35 #include "smack-check.h"
  36 #include "security-server.h"
  37 #include "security-server-common.h"
  38 #include "security-server-comm.h"
  39
  40 #if 0
  41 void printhex(unsigned char *data, int size)
  42 {
  43         int i;
  44         for(i=0;i<size;i++)
  45         {
  46                 if(data[i] < 0xF)
  47                         printf("0");
  48
  49                 printf("%X ", data[i]);
  50                 if(((i+1) % 16) == 0 && i != 0)
  51                         printf("\n");
  52         }
  53         printf("\n");
  54 }
  55
  56
  57 char *read_cmdline_from_proc(pid_t pid)
  58 {
  59         int memsize = 32;
  60         char path[32];
  61         char *cmdline = NULL;
  62
  63         snprintf(path, sizeof(path), "/proc/%d/exe", pid);
  64
  65         cmdline = malloc(32);
  66         if(cmdline == NULL)
  67         {
  68                 SEC_SVR_DBG("%s", "Out of memory");
  69                 goto error;
  70         }
  71
  72         while(1)
  73         {
  74                 bzero(cmdline, memsize);
  75                 /* readlink() may have security hole in normal symbolic link. *
  76                  * But this link is located at proc fs that only kernel can change */
  77                 readlink(path, cmdline, memsize);       /* FlawFinder: ignore */
  78 SEC_SVR_DBG("pid: %d, cmdline: %s", pid, cmdline);
  79
  80                 /* Check it's truncated */
  81                 if(cmdline[memsize -1] != 0)
  82                 {
  83                         cmdline = (char *)realloc(cmdline, sizeof(char) * (memsize + 32));
  84                         memsize += 32;
  85                         if(cmdline == NULL)
  86                         {
  87                                 SEC_SVR_DBG("%s", "Out of memory");
  88                                 goto error;
  89                         }
  90                 }
  91                 else
  92                         break;
  93         }
  94
  95 error:
  96         return cmdline;
  97 }
  98 #endif
  99
 100
 101 /* We may need to filter error code */
 102 int convert_to_public_error_code(int err_code)
 103 {
 104         /* Do we need this? */
 105         return err_code;
 106 }
 107
 108 static int send_exec_path_request(int sock_fd, pid_t pid)
 109 {
 110         basic_header hdr;
 111         int retval;
 112         unsigned char buf[sizeof(hdr) + sizeof(pid)];
 113
 114         /* Assemble header */
 115         hdr.version = SECURITY_SERVER_MSG_VERSION;
 116         hdr.msg_id = SECURITY_SERVER_MSG_TYPE_EXE_PATH_REQUEST;
 117         hdr.msg_len = sizeof(pid);
 118
 119         memcpy(buf, &hdr, sizeof(hdr));
 120         memcpy(buf + sizeof(hdr), &pid, sizeof(pid));
 121
 122         /* Check poll */
 123         retval = check_socket_poll(sock_fd, POLLOUT, SECURITY_SERVER_SOCKET_TIMEOUT_MILISECOND);
 124         if(retval == SECURITY_SERVER_ERROR_POLL)
 125         {
 126                 SEC_SVR_ERR("%s", "poll() error");
 127                 return SECURITY_SERVER_ERROR_SEND_FAILED;
 128         }
 129         if(retval == SECURITY_SERVER_ERROR_TIMEOUT)
 130         {
 131                 SEC_SVR_ERR("%s", "poll() timeout");
 132                 return SECURITY_SERVER_ERROR_SEND_FAILED;
 133         }
 134
 135         /* Send to server */
 136         retval = TEMP_FAILURE_RETRY(write(sock_fd, buf, sizeof(buf)));
 137         if(retval < (ssize_t)sizeof(buf))
 138         {
 139                 /* Write error */
 140                 SEC_SVR_ERR("Error on write(): %d", retval);
 141                 return SECURITY_SERVER_ERROR_SEND_FAILED;
 142         }
 143         return SECURITY_SERVER_SUCCESS;
 144 }
 145
 146 static int recv_exec_path_response(int sockfd, response_header *hdr, char** path)
 147 {
 148         size_t size = 0;
 149         char* buf = NULL;
 150         int retval;
 151
 152         if (*path)
 153         {
 154                 SEC_SVR_ERR("path should be NULL");
 155                 return SECURITY_SERVER_ERROR_INPUT_PARAM;
 156         }
 157
 158         retval = recv_generic_response(sockfd, hdr);
 159         if(retval != SECURITY_SERVER_SUCCESS)
 160         {
 161                 SEC_SVR_ERR("Failed to get response: %d", retval);
 162                 return return_code_to_error_code(hdr->return_code);
 163         }
 164
 165         retval = TEMP_FAILURE_RETRY(read(sockfd, &size, sizeof(size_t)));
 166         if(retval < (ssize_t)sizeof(size_t) || size == 0)
 167         {
 168                 /* Error on socket */
 169                 SEC_SVR_ERR("read() failed: %d", retval);
 170                 return SECURITY_SERVER_ERROR_RECV_FAILED;
 171         }
 172         buf = (char*)malloc((size+1)*sizeof(char));
 173         if(!buf)
 174         {
 175                 SEC_SVR_ERR("malloc() failed. Size requested: %d", size*sizeof(char));
 176                 return SECURITY_SERVER_ERROR_OUT_OF_MEMORY;
 177         }
 178
 179         retval = TEMP_FAILURE_RETRY(read(sockfd, buf, size));
 180         if(retval < (ssize_t)size)
 181         {
 182                 /* Error on socket */
 183                 SEC_SVR_ERR("read() failed: %d", retval);
 184                 free(buf);
 185                 return SECURITY_SERVER_ERROR_RECV_FAILED;
 186         }
 187         // terminate string
 188         buf[size] = '\0';
 189
 190         *path = buf;
 191         return SECURITY_SERVER_SUCCESS;
 192 }
 193
 194 static int get_exec_path(pid_t pid, char** exe)
 195 {
 196         int sockfd = -1;
 197         int ret = 0;
 198         char* path = NULL;
 199         response_header hdr;
 200         if (SECURITY_SERVER_SUCCESS != connect_to_server(&sockfd))
 201                 goto out;
 202
 203         ret = send_exec_path_request(sockfd, pid);
 204         if (ret != SECURITY_SERVER_SUCCESS)
 205         {
 206                 /* Error on socket */
 207                 SEC_SVR_ERR("Client: Send failed: %d", ret);
 208                 goto out;
 209         }
 210
 211         ret = recv_exec_path_response(sockfd, &hdr, &path);
 212         if (ret != SECURITY_SERVER_SUCCESS)
 213         {
 214                 SEC_SVR_ERR("Client: Recv failed: %d", ret);
 215                 goto out;
 216         }
 217
 218         ret = return_code_to_error_code(hdr.return_code);
 219         if (hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 220                 SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 221         else if (hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_EXE_PATH_RESPONSE)
 222         {
 223                 SEC_SVR_ERR("Client: Wrong response type.");
 224                 ret = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 225         }
 226
 227 out:
 228         if (sockfd != -1)
 229                 close(sockfd);
 230
 231         if (ret == SECURITY_SERVER_SUCCESS)
 232         {
 233                 *exe = path;
 234                 path = NULL;
 235         }
 236         free(path);
 237         return ret;
 238 }
 239
 240
 241         SECURITY_SERVER_API
 242 int security_server_get_gid(const char *object)
 243 {
 244         int sockfd = -1, retval, gid;
 245         response_header hdr;
 246
 247         if(object == NULL)
 248         {
 249                 SEC_SVR_ERR("%s", "Client: object is null or object is too big");
 250                 retval = SECURITY_SERVER_API_ERROR_INPUT_PARAM;
 251                 goto error;
 252         }
 253         if( strlen(object) > SECURITY_SERVER_MAX_OBJ_NAME )
 254         {
 255                 SEC_SVR_ERR("%s", "object is null or object is too big");
 256                 retval = SECURITY_SERVER_API_ERROR_INPUT_PARAM;
 257                 goto error;
 258         }
 259
 260         if(strlen(object) == 0)
 261         {
 262                 SEC_SVR_ERR("Client: object is is empty");
 263                 retval = SECURITY_SERVER_API_ERROR_INPUT_PARAM;
 264                 goto error;
 265         }
 266
 267         SEC_SVR_DBG("%s", "Client: security_server_get_gid() is called");
 268         retval = connect_to_server(&sockfd);
 269         if(retval != SECURITY_SERVER_SUCCESS)
 270         {
 271                 /* Error on socket */
 272                 SEC_SVR_ERR("Connection failed: %d", retval);
 273                 goto error;
 274         }
 275         SEC_SVR_DBG("%s", "Client: Security server has been connected");
 276
 277         /* make request packet and send to server*/
 278         retval = send_gid_request(sockfd, object);
 279         SEC_SVR_DBG("%s", "Client: gid request has been sent");
 280         if(retval != SECURITY_SERVER_SUCCESS)
 281         {
 282                 /* Error on socket */
 283                 SEC_SVR_ERR("Send gid request failed: %d", retval);
 284                 goto error;
 285         }
 286
 287         /* Receive response */
 288         retval = recv_get_gid_response(sockfd, &hdr, &gid);
 289         if(retval != SECURITY_SERVER_SUCCESS)
 290         {
 291                 SEC_SVR_ERR("Client: Receive response failed: %d", retval);
 292                 goto error;
 293         }
 294         SEC_SVR_DBG("%s", "Client: get gid response has been received");
 295
 296         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_GID_RESPONSE)       /* Wrong response */
 297         {
 298                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 299                 {
 300                         /* There must be some error */
 301                         SEC_SVR_ERR("Client: It'll be an error. return code:%d", hdr.return_code);
 302                         retval = return_code_to_error_code(hdr.return_code);
 303                         goto error;
 304                 }
 305                 else
 306                 {
 307                         /* Something wrong with response */
 308                         SEC_SVR_ERR("Client: Something wrong with response:%d", hdr.basic_hdr.msg_id);
 309                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 310                         goto error;
 311                 }
 312         }
 313
 314         SEC_SVR_DBG("received gid is %d", gid);
 315         retval = gid;
 316
 317 error:
 318         if(sockfd > 0)
 319                 close(sockfd);
 320         /* If error happened */
 321         if(retval < 0)
 322                 retval = convert_to_public_error_code(retval);
 323
 324         return retval;
 325 }
 326
 327
 328
 329
 330         SECURITY_SERVER_API
 331 int security_server_get_object_name(gid_t gid, char *object, size_t max_object_size)
 332 {
 333         int sockfd = -1, retval;
 334         response_header hdr;
 335
 336         if(object == NULL)
 337         {
 338                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 339                 goto error;
 340         }
 341
 342         retval = connect_to_server(&sockfd);
 343         if(retval != SECURITY_SERVER_SUCCESS)
 344         {
 345                 /* Error on socket */
 346                 SEC_SVR_ERR("Client: connect to server failed: %d", retval);
 347                 goto error;
 348         }
 349
 350         /* make request packet */
 351         retval = send_object_name_request(sockfd, gid);
 352         if(retval != SECURITY_SERVER_SUCCESS)
 353         {
 354                 /* Error on socket */
 355                 SEC_SVR_ERR("Client: cannot send request: %d", retval);
 356                 goto error;
 357         }
 358
 359         retval = recv_get_object_name(sockfd, &hdr, object, max_object_size);
 360         if(retval != SECURITY_SERVER_SUCCESS)
 361         {
 362                 SEC_SVR_ERR("Client: Receive response failed: %d", retval);
 363                 goto error;
 364         }
 365
 366         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_OBJECT_NAME_RESPONSE)       /* Wrong response */
 367         {
 368                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 369                 {
 370                         /* There must be some error */
 371                         SEC_SVR_ERR("Client: There is error on response: return code:%d", hdr.basic_hdr.msg_id);
 372                         retval = return_code_to_error_code(hdr.return_code);
 373                 }
 374                 else
 375                 {
 376                         /* Something wrong with response */
 377                         SEC_SVR_ERR("Client: Some unexpected error happene: return code:%d", hdr.basic_hdr.msg_id);
 378                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 379                 }
 380                 goto error;
 381         }
 382
 383 error:
 384         if(sockfd > 0)
 385                 close(sockfd);
 386
 387         retval = convert_to_public_error_code(retval);
 388         return retval;
 389 }
 390
 391
 392
 393         SECURITY_SERVER_API
 394 int security_server_request_cookie(char *cookie, size_t max_cookie)
 395 {
 396         int sockfd = -1, retval;
 397         response_header hdr;
 398
 399         if(cookie == NULL)
 400         {
 401                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 402                 goto error;
 403         }
 404         if(max_cookie < SECURITY_SERVER_COOKIE_LEN)
 405         {
 406                 retval = SECURITY_SERVER_ERROR_BUFFER_TOO_SMALL;
 407                 goto error;
 408         }
 409
 410         SEC_SVR_DBG("%s", "Client: security_server_request_cookie() is called");
 411         retval = connect_to_server(&sockfd);
 412         if(retval != SECURITY_SERVER_SUCCESS)
 413         {
 414                 /* Error on socket */
 415                 SEC_SVR_ERR("%s", "Client: connection failed");
 416                 goto error;
 417         }
 418
 419         /* make request packet */
 420         retval = send_cookie_request(sockfd);
 421         if(retval != SECURITY_SERVER_SUCCESS)
 422         {
 423                 /* Error on socket */
 424                 SEC_SVR_ERR("Client: send cookie failed: %d", retval);
 425                 goto error;
 426         }
 427         SEC_SVR_DBG("%s", "Client: cookie request sent");
 428         retval = recv_cookie(sockfd, &hdr, cookie);
 429
 430         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_COOKIE_RESPONSE)    /* Wrong response */
 431         {
 432                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 433                 {
 434                         /* There must be some error */
 435                         SEC_SVR_ERR("Client ERROR: There is an error on response. return code:%d", hdr.return_code);
 436                         retval = return_code_to_error_code(hdr.return_code);
 437                 }
 438                 else
 439                 {
 440                         /* Something wrong with response */
 441                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 442                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 443                 }
 444                 goto error;
 445         }
 446         SEC_SVR_DBG("%s", "Client: cookie received");
 447
 448 error:
 449         if(sockfd > 0)
 450                 close(sockfd);
 451
 452         retval = convert_to_public_error_code(retval);
 453         return retval;
 454 }
 455
 456
 457
 458
 459
 460         SECURITY_SERVER_API
 461 int security_server_check_privilege(const char *cookie, gid_t privilege)
 462 {
 463         int sockfd = -1, retval;
 464         response_header hdr;
 465
 466         if(cookie == NULL)
 467         {
 468                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 469                 goto error;
 470         }
 471
 472         retval = connect_to_server(&sockfd);
 473         if(retval != SECURITY_SERVER_SUCCESS)
 474         {
 475                 /* Error on socket */
 476                 goto error;
 477         }
 478
 479         /* make request packet */
 480         retval = send_privilege_check_request(sockfd, cookie, privilege);
 481         if(retval != SECURITY_SERVER_SUCCESS)
 482         {
 483                 /* Error on socket */
 484                 SEC_SVR_ERR("Send failed: %d", retval);
 485                 goto error;
 486         }
 487
 488         retval = recv_privilege_check_response(sockfd, &hdr);
 489
 490         retval = return_code_to_error_code(hdr.return_code);
 491         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_CHECK_PRIVILEGE_RESPONSE)   /* Wrong response */
 492         {
 493                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 494                 {
 495                         /* There must be some error */
 496                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 497                 }
 498                 else
 499                 {
 500                         /* Something wrong with response */
 501                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 502                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 503                 }
 504                 goto error;
 505         }
 506
 507 error:
 508         if(sockfd > 0)
 509                 close(sockfd);
 510
 511         retval = convert_to_public_error_code(retval);
 512         return retval;
 513 }
 514
 515
 516         SECURITY_SERVER_API
 517 int security_server_check_privilege_by_cookie(const char *cookie,
 518                                               const char *object,
 519                                               const char *access_rights)
 520 {
 521         int sockfd = -1, retval;
 522         int olen, alen;
 523         response_header hdr;
 524
 525         if(cookie == NULL || object == NULL || access_rights == NULL)
 526         {
 527                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 528                 goto error;
 529         }
 530
 531         olen = strlen(object);
 532         alen = strlen(access_rights);
 533
 534         if (olen > SMACK_LABEL_LEN || alen > MAX_MODE_STR_LEN)
 535         {
 536                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 537                 goto error;
 538         }
 539
 540         retval = connect_to_server(&sockfd);
 541         if(retval != SECURITY_SERVER_SUCCESS)
 542         {
 543                 /* Error on socket */
 544                 goto error;
 545         }
 546
 547         /* make request packet */
 548         retval = send_privilege_check_new_request(
 549                      sockfd, cookie, object, access_rights);
 550         if(retval != SECURITY_SERVER_SUCCESS)
 551         {
 552                 /* Error on socket */
 553                 SEC_SVR_ERR("Send failed: %d", retval);
 554                 goto error;
 555         }
 556
 557         retval = recv_privilege_check_new_response(sockfd, &hdr);
 558
 559         retval = return_code_to_error_code(hdr.return_code);
 560         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_CHECK_PRIVILEGE_NEW_RESPONSE)
 561         /* Wrong response */
 562         {
 563                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 564                 {
 565                         /* There must be some error */
 566                         SEC_SVR_ERR("Client: Error has been received. return code:%d",
 567                                     hdr.return_code);
 568                 }
 569                 else
 570                 {
 571                         /* Something wrong with response */
 572                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 573                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 574                 }
 575                 goto error;
 576         }
 577
 578 error:
 579         if(sockfd >= 0)
 580                 close(sockfd);
 581
 582         retval = convert_to_public_error_code(retval);
 583         return retval;
 584 }
 585
 586         SECURITY_SERVER_API
 587 int security_server_check_privilege_by_sockfd(int sockfd,
 588                                               const char *object,
 589                                               const char *access_rights)
 590 {
 591     if (!smack_check())
 592     {
 593         SEC_SVR_DBG("%s","No SMACK support on device");
 594         return SECURITY_SERVER_API_SUCCESS;
 595     }
 596
 597     char *subject;
 598     int ret;
 599     char * path = NULL;
 600
 601     //for get socket options
 602     struct ucred cr;
 603     unsigned int len = sizeof(cr);
 604
 605     //SMACK runtime check
 606     if (!smack_runtime_check())
 607     {
 608         SEC_SVR_DBG("%s","No SMACK support on device");
 609         return SECURITY_SERVER_API_SUCCESS;
 610     }
 611
 612     ret = smack_new_label_from_socket(sockfd, &subject);
 613     if (ret != 0)
 614         return SECURITY_SERVER_API_ERROR_SERVER_ERROR;
 615
 616     len = sizeof(cr);
 617     ret = getsockopt(sockfd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
 618     if (ret < 0) {
 619         SEC_SVR_ERR("Error in getsockopt(). Errno: %s", strerror(errno));
 620         ret = 0;
 621         goto err;
 622     }
 623     ret = get_exec_path(cr.pid, &path);
 624     if (SECURITY_SERVER_SUCCESS != ret)
 625         SEC_SVR_ERR("Failed to read executable path for process %d", cr.pid);
 626
 627     ret = security_server_check_privilege_by_pid(cr.pid, object, access_rights);
 628     if (ret == SECURITY_SERVER_RETURN_CODE_SUCCESS)
 629         ret = 1;
 630     else
 631         ret = 0;
 632
 633 err:
 634
 635     SEC_SVR_DBG("security_server_check_privilege_by_pid returned %d", ret);
 636     if (ret > 0)
 637         SEC_SVR_DBG("SS_SMACK: caller_pid=%d, subject=%s, object=%s, access=%s, result=%d, caller_path=%s", cr.pid, subject, object, access_rights, ret, path);
 638     else
 639         SEC_SVR_ERR("SS_SMACK: caller_pid=%d, subject=%s, object=%s, access=%s, result=%d, caller_path=%s", cr.pid, subject, object, access_rights, ret, path);
 640
 641     free(path);
 642     free(subject);
 643     if (ret == 1)
 644     {
 645         return SECURITY_SERVER_API_SUCCESS;
 646     }
 647     else
 648     {
 649         return SECURITY_SERVER_API_ERROR_ACCESS_DENIED;
 650     }
 651 }
 652
 653
 654         SECURITY_SERVER_API
 655 int security_server_get_cookie_size(void)
 656 {
 657         return SECURITY_SERVER_COOKIE_LEN;
 658 }
 659
 660
 661
 662         SECURITY_SERVER_API
 663 int security_server_get_cookie_pid(const char *cookie)
 664 {
 665         int sockfd = -1, retval, pid = -1;
 666         response_header hdr;
 667
 668         if(cookie == NULL)
 669         {
 670                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 671                 goto error;
 672         }
 673
 674         retval = connect_to_server(&sockfd);
 675         if(retval != SECURITY_SERVER_SUCCESS)
 676         {
 677                 /* Error on socket */
 678                 goto error;
 679         }
 680
 681         /* make request packet */
 682         retval = send_pid_request(sockfd, cookie);
 683         if(retval != SECURITY_SERVER_SUCCESS)
 684         {
 685                 /* Error on socket */
 686                 SEC_SVR_ERR("Client: Send failed: %d", retval);
 687                 goto error;
 688         }
 689
 690         retval = recv_pid_response(sockfd, &hdr, &pid);
 691
 692         retval = return_code_to_error_code(hdr.return_code);
 693         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_PID_RESPONSE)       /* Wrong response */
 694         {
 695                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 696                 {
 697                         /* There must be some error */
 698                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 699                 }
 700                 else
 701                 {
 702                         /* Something wrong with response */
 703                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 704                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 705                 }
 706                 goto error;
 707         }
 708         if(hdr.return_code == SECURITY_SERVER_RETURN_CODE_NO_SUCH_COOKIE)
 709         {
 710                 SEC_SVR_ERR("%s"," Client: There is no such cookie exist");
 711         }
 712
 713 error:
 714         if(sockfd > 0)
 715                 close(sockfd);
 716
 717         retval = convert_to_public_error_code(retval);
 718         if(retval == 0)
 719                 return pid;
 720
 721         return retval;
 722 }
 723
 724
 725
 726         SECURITY_SERVER_API
 727 int security_server_launch_debug_tool(int argc, const char **argv)
 728 {
 729         int sockfd = -1, retval;
 730         response_header hdr;
 731
 732         if(argc < 1 || argv == NULL || argv[0] == NULL)
 733         {
 734                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 735                 goto error;
 736         }
 737
 738         if(argc == 1)
 739         {
 740                 if(strcmp(argv[0], SECURITY_SERVER_KILL_APP_PATH) != 0)
 741                 {
 742                         retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 743                         goto error;
 744                 }
 745         }
 746
 747         /* Check the caller is developer shell */
 748         retval = getuid();
 749         if(retval != SECURITY_SERVER_DEVELOPER_UID)
 750         {
 751                 SEC_SVR_ERR("Client: It's not allowed to call this API by uid %d", retval);
 752                 retval = SECURITY_SERVER_ERROR_AUTHENTICATION_FAILED;
 753                 goto error;
 754         }
 755
 756         retval = connect_to_server(&sockfd);
 757         if(retval != SECURITY_SERVER_SUCCESS)
 758         {
 759                 /* Error on socket */
 760                 goto error;
 761         }
 762
 763         /* make request packet */
 764         retval = send_launch_tool_request(sockfd, argc, argv);
 765         if(retval != SECURITY_SERVER_SUCCESS)
 766         {
 767                 /* Error on socket */
 768                 SEC_SVR_ERR("Client: Send failed: %d", retval);
 769                 goto error;
 770         }
 771
 772         retval = recv_generic_response(sockfd, &hdr);
 773
 774         retval = return_code_to_error_code(hdr.return_code);
 775         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_TOOL_RESPONSE)      /* Wrong response */
 776         {
 777                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 778                 {
 779                         /* There must be some error */
 780                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 781                 }
 782                 else
 783                 {
 784                         /* Something wrong with response */
 785                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 786                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 787                 }
 788                 goto error;
 789         }
 790
 791 error:
 792         if(sockfd > 0)
 793                 close(sockfd);
 794
 795         retval = convert_to_public_error_code(retval);
 796         return retval;
 797 }
 798
 799
 800
 801         SECURITY_SERVER_API
 802 int security_server_is_pwd_valid(unsigned int *current_attempts,
 803         unsigned int *max_attempts,
 804         unsigned int *valid_secs)
 805 {
 806         int sockfd = -1, retval = SECURITY_SERVER_ERROR_UNKNOWN;
 807         response_header hdr;
 808
 809         if(current_attempts == NULL || max_attempts == NULL ||valid_secs == NULL)
 810         {
 811                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 812                 goto error;
 813         }
 814
 815         /* Authenticate self that is setting app  goes here */
 816         /* 1st, check cmdline which is setting app */
 817         /* 2nd, check /proc/self/attr/current for the SMACK label */
 818
 819         retval = connect_to_server(&sockfd);
 820         if(retval != SECURITY_SERVER_SUCCESS)
 821         {
 822                 /* Error on socket */
 823                 goto error;
 824         }
 825
 826         /* make request packet */
 827         retval = send_valid_pwd_request(sockfd);
 828         if(retval != SECURITY_SERVER_SUCCESS)
 829         {
 830                 /* Error on socket */
 831                 SEC_SVR_ERR("Client: Send failed: %d", retval);
 832                 goto error;
 833         }
 834
 835         retval = recv_pwd_response(sockfd, &hdr, current_attempts, max_attempts, valid_secs);
 836
 837         retval = return_code_to_error_code(hdr.return_code);
 838         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_VALID_PWD_RESPONSE) /* Wrong response */
 839         {
 840                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_VALID_PWD_RESPONSE)
 841                 {
 842                         /* There must be some error */
 843                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 844                 }
 845                 else
 846                 {
 847                         /* Something wrong with response */
 848                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 849                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 850                 }
 851                 goto error;
 852         }
 853 error:
 854         if(sockfd > 0)
 855                 close(sockfd);
 856
 857         retval = convert_to_public_error_code(retval);
 858         return retval;
 859 }
 860
 861
 862
 863         SECURITY_SERVER_API
 864 int security_server_set_pwd(const char *cur_pwd,
 865                         const char *new_pwd,
 866                         const unsigned int max_challenge,
 867                         const unsigned int valid_period_in_days)
 868 {
 869         int sockfd = -1, retval;
 870         response_header hdr;
 871
 872         if(new_pwd == NULL || strlen(new_pwd) > SECURITY_SERVER_MAX_PASSWORD_LEN)
 873         {
 874                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
 875                 goto error;
 876         }
 877
 878         /* Authenticate self that is setting app  goes here */
 879         /* 1st, check cmdline which is setting app */
 880         /* 2nd, check /proc/self/attr/current for the SMACK label */
 881
 882         retval = connect_to_server(&sockfd);
 883         if(retval != SECURITY_SERVER_SUCCESS)
 884         {
 885                 /* Error on socket */
 886                 goto error;
 887         }
 888
 889         /* make request packet */
 890         retval = send_set_pwd_request(sockfd, cur_pwd, new_pwd, max_challenge, valid_period_in_days);
 891         if(retval != SECURITY_SERVER_SUCCESS)
 892         {
 893                 /* Error on socket */
 894                 SEC_SVR_ERR("Client: Send failed: %d", retval);
 895                 goto error;
 896         }
 897
 898         retval = recv_generic_response(sockfd, &hdr);
 899
 900         retval = return_code_to_error_code(hdr.return_code);
 901         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_SET_PWD_RESPONSE)   /* Wrong response */
 902         {
 903                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 904                 {
 905                         /* There must be some error */
 906                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 907                 }
 908                 else
 909                 {
 910                         /* Something wrong with response */
 911                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 912                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 913                 }
 914                 goto error;
 915         }
 916 error:
 917         if(sockfd > 0)
 918                 close(sockfd);
 919
 920         retval = convert_to_public_error_code(retval);
 921         return retval;
 922 }
 923
 924
 925         SECURITY_SERVER_API
 926 int security_server_set_pwd_validity(const unsigned int valid_period_in_days)
 927 {
 928     int sockfd = -1, retval;
 929     response_header hdr;
 930
 931     retval = connect_to_server(&sockfd);
 932     if(retval != SECURITY_SERVER_SUCCESS)
 933     {
 934         /* Error on socket */
 935         goto error;
 936     }
 937
 938     /* make request packet */
 939     retval = send_set_pwd_validity_request(sockfd, valid_period_in_days);
 940     if(retval != SECURITY_SERVER_SUCCESS)
 941     {
 942         /* Error on socket */
 943         SEC_SVR_ERR("Client: Send failed: %d", retval);
 944         goto error;
 945     }
 946
 947     retval = recv_generic_response(sockfd, &hdr);
 948
 949     retval = return_code_to_error_code(hdr.return_code);
 950     if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_SET_PWD_VALIDITY_RESPONSE)   /* Wrong response */
 951     {
 952         if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
 953         {
 954             /* There must be some error */
 955             SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
 956         }
 957         else
 958         {
 959             /* Something wrong with response */
 960             SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
 961             retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
 962         }
 963         goto error;
 964     }
 965 error:
 966     if(sockfd > 0)
 967         close(sockfd);
 968
 969     retval = convert_to_public_error_code(retval);
 970     return retval;
 971 }
 972
 973         SECURITY_SERVER_API
 974 int security_server_set_pwd_max_challenge(const unsigned int max_challenge)
 975 {
 976     int sockfd = -1, retval;
 977     response_header hdr;
 978
 979     retval = connect_to_server(&sockfd);
 980     if(retval != SECURITY_SERVER_SUCCESS)
 981     {
 982         /* Error on socket */
 983         goto error;
 984     }
 985
 986     /* make request packet */
 987     retval = send_set_pwd_max_challenge_request(sockfd, max_challenge);
 988     if(retval != SECURITY_SERVER_SUCCESS)
 989     {
 990         /* Error on socket */
 991         SEC_SVR_ERR("Client: Send failed: %d", retval);
 992         goto error;
 993     }
 994
 995     retval = recv_generic_response(sockfd, &hdr);
 996
 997     retval = return_code_to_error_code(hdr.return_code);
 998     if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_SET_PWD_MAX_CHALLENGE_RESPONSE)   /* Wrong response */
 999     {
1000         if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
1001         {
1002             /* There must be some error */
1003             SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1004         }
1005         else
1006         {
1007             /* Something wrong with response */
1008             SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1009             retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1010         }
1011         goto error;
1012     }
1013 error:
1014     if(sockfd > 0)
1015         close(sockfd);
1016
1017     retval = convert_to_public_error_code(retval);
1018     return retval;
1019 }
1020
1021
1022
1023         SECURITY_SERVER_API
1024 int security_server_reset_pwd(const char *new_pwd,
1025                         const unsigned int max_challenge,
1026                         const unsigned int valid_period_in_days)
1027 {
1028         int sockfd = -1, retval;
1029         response_header hdr;
1030
1031         if(new_pwd == NULL || strlen(new_pwd) > SECURITY_SERVER_MAX_PASSWORD_LEN)
1032         {
1033                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
1034                 goto error;
1035         }
1036
1037         /* Authenticate self that is setting app  goes here */
1038         /* 1st, check cmdline which is setting app */
1039         /* 2nd, check /proc/self/attr/current for the SMACK label */
1040
1041         retval = connect_to_server(&sockfd);
1042         if(retval != SECURITY_SERVER_SUCCESS)
1043         {
1044                 /* Error on socket */
1045                 goto error;
1046         }
1047
1048         /* make request packet */
1049         retval = send_reset_pwd_request(sockfd, new_pwd, max_challenge, valid_period_in_days);
1050         if(retval != SECURITY_SERVER_SUCCESS)
1051         {
1052                 /* Error on socket */
1053                 SEC_SVR_ERR("Client: Send failed: %d", retval);
1054                 goto error;
1055         }
1056
1057         retval = recv_generic_response(sockfd, &hdr);
1058
1059         retval = return_code_to_error_code(hdr.return_code);
1060         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_RESET_PWD_RESPONSE) /* Wrong response */
1061         {
1062                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
1063                 {
1064                         /* There must be some error */
1065                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1066                 }
1067                 else
1068                 {
1069                         /* Something wrong with response */
1070                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1071                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1072                 }
1073                 goto error;
1074         }
1075 error:
1076         if(sockfd > 0)
1077                 close(sockfd);
1078
1079         retval = convert_to_public_error_code(retval);
1080         return retval;
1081 }
1082
1083
1084
1085         SECURITY_SERVER_API
1086 int security_server_chk_pwd(const char *challenge,
1087         unsigned int *current_attempt,
1088         unsigned int *max_attempts,
1089         unsigned int *valid_secs)
1090 {
1091         int sockfd = -1, retval;
1092         response_header hdr;
1093
1094         if(challenge == NULL || strlen(challenge) > SECURITY_SERVER_MAX_PASSWORD_LEN
1095                 || current_attempt == NULL || max_attempts == NULL || valid_secs == NULL)
1096         {
1097                 retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
1098                 goto error;
1099         }
1100
1101         /* Authenticate self goes here */
1102
1103         retval = connect_to_server(&sockfd);
1104         if(retval != SECURITY_SERVER_SUCCESS)
1105         {
1106                 /* Error on socket */
1107                 goto error;
1108         }
1109
1110         /* make request packet */
1111         retval = send_chk_pwd_request(sockfd, challenge);
1112         if(retval != SECURITY_SERVER_SUCCESS)
1113         {
1114                 /* Error on socket */
1115                 SEC_SVR_ERR("Client: Send failed: %d", retval);
1116                 goto error;
1117         }
1118
1119         retval = recv_pwd_response(sockfd, &hdr, current_attempt, max_attempts, valid_secs);
1120
1121         retval = return_code_to_error_code(hdr.return_code);
1122         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_CHK_PWD_RESPONSE)   /* Wrong response */
1123         {
1124                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
1125                 {
1126                         /* There must be some error */
1127                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1128                 }
1129                 else
1130                 {
1131                         /* Something wrong with response */
1132                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1133                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1134                 }
1135                 goto error;
1136         }
1137 error:
1138         if(sockfd > 0)
1139                 close(sockfd);
1140
1141         retval = convert_to_public_error_code(retval);
1142         return retval;
1143 }
1144
1145         SECURITY_SERVER_API
1146 int security_server_set_pwd_history(int number_of_history)
1147 {
1148         int sockfd = -1, retval;
1149         response_header hdr;
1150
1151         if(number_of_history > SECURITY_SERVER_MAX_PASSWORD_HISTORY || number_of_history < 0)
1152                 return SECURITY_SERVER_API_ERROR_INPUT_PARAM;
1153
1154         /* Authenticate self that is setting app  goes here */
1155         /* 1st, check cmdline which is setting app */
1156         /* 2nd, check /proc/self/attr/current for the SMACK label */
1157
1158         retval = connect_to_server(&sockfd);
1159         if(retval != SECURITY_SERVER_SUCCESS)
1160         {
1161                 /* Error on socket */
1162                 goto error;
1163         }
1164
1165         /* make request packet */
1166         retval = send_set_pwd_history_request(sockfd, number_of_history);
1167         if(retval != SECURITY_SERVER_SUCCESS)
1168         {
1169                 /* Error on socket */
1170                 SEC_SVR_ERR("Client: Send failed: %d", retval);
1171                 goto error;
1172         }
1173         retval = recv_generic_response(sockfd, &hdr);
1174
1175         retval = return_code_to_error_code(hdr.return_code);
1176         if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_SET_PWD_HISTORY_RESPONSE)   /* Wrong response */
1177         {
1178                 if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
1179                 {
1180                         /* There must be some error */
1181                         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1182                 }
1183                 else
1184                 {
1185                         /* Something wrong with response */
1186                         SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1187                         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1188                 }
1189                 goto error;
1190         }
1191 error:
1192         if(sockfd > 0)
1193                 close(sockfd);
1194
1195         retval = convert_to_public_error_code(retval);
1196         return retval;
1197 }
1198
1199 SECURITY_SERVER_API
1200 char * security_server_get_smacklabel_cookie(const char * cookie)
1201 {
1202     char * label = NULL;
1203     int sockfd = -1, retval;
1204     response_header hdr;
1205
1206     if(cookie == NULL)
1207     {
1208         retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
1209         goto error;
1210     }
1211
1212     retval = connect_to_server(&sockfd);
1213     if(retval != SECURITY_SERVER_SUCCESS)
1214     {
1215         /* Error on socket */
1216         goto error;
1217     }
1218
1219     /* make request packet */
1220     retval = send_smack_request(sockfd, cookie);
1221     if(retval != SECURITY_SERVER_SUCCESS)
1222     {
1223         /* Error on socket */
1224         SEC_SVR_ERR("Client: Send failed: %d", retval);
1225         goto error;
1226     }
1227
1228     //allocating buffer for storing SMACK label received from server
1229     label = calloc(SMACK_LABEL_LEN + 1, 1);
1230     if(NULL == label)
1231     {
1232         SEC_SVR_ERR("Client ERROR: Memory allocation error");
1233         goto error;
1234     }
1235
1236     retval = recv_smack_response(sockfd, &hdr, label);
1237
1238     retval = return_code_to_error_code(hdr.return_code);
1239     if(hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_SMACK_RESPONSE) /* Wrong response */
1240     {
1241         if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE)
1242         {
1243             /* There must be some error */
1244             SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1245         }
1246         else
1247         {
1248             /* Something wrong with response */
1249             SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1250             retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1251         }
1252         goto error;
1253     }
1254     if(hdr.return_code == SECURITY_SERVER_RETURN_CODE_NO_SUCH_COOKIE)
1255     {
1256         SEC_SVR_ERR("%s"," Client: There is no such cookie exist");
1257     }
1258
1259 error:
1260     if(sockfd > 0)
1261         close(sockfd);
1262
1263     retval = convert_to_public_error_code(retval);
1264     if(retval == 0)
1265         return label;
1266
1267     if(NULL != label)
1268         free(label);
1269
1270     return NULL;
1271 }
1272
1273 SECURITY_SERVER_API
1274 char * security_server_get_smacklabel_sockfd(int fd)
1275 {
1276     char * label = NULL;
1277
1278     if (!smack_check())
1279     {
1280         SEC_SVR_DBG("%s","No SMACK support on device");
1281         label = (char*) malloc(1);
1282         if (label) label[0] = '\0';
1283         return label;
1284     }
1285
1286     if (smack_new_label_from_socket(fd, &label) != 0)
1287     {
1288         SEC_SVR_ERR("Client ERROR: Unable to get socket SMACK label");
1289         return NULL;
1290     }
1291
1292     return label;
1293 }
1294
1295 SECURITY_SERVER_API
1296 int security_server_app_give_access(const char *customer_label, int customer_pid)
1297 {
1298     int sockfd = -1, retval;
1299     response_header hdr;
1300
1301     if (1 != smack_check())
1302         return SECURITY_SERVER_SUCCESS;
1303
1304     retval = connect_to_server(&sockfd);
1305     if(retval != SECURITY_SERVER_SUCCESS)
1306     {
1307         /* Error on socket */
1308         goto out;
1309     }
1310
1311     retval = send_app_give_access(sockfd, customer_label, customer_pid);
1312     if(retval != SECURITY_SERVER_SUCCESS)
1313     {
1314         /* Error on socket */
1315         SEC_SVR_ERR("Client: Send failed: %d", retval);
1316         goto out;
1317     }
1318
1319     retval = recv_generic_response(sockfd, &hdr);
1320
1321     retval = return_code_to_error_code(hdr.return_code);
1322     if(hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE) {
1323         SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1324     } else if (hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_APP_GIVE_ACCESS_RESPONSE) {
1325         SEC_SVR_ERR("Client: Wrong response type.");
1326         retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1327     }
1328 out:
1329     if(sockfd > 0)
1330         close(sockfd);
1331
1332     return convert_to_public_error_code(retval);
1333 }
1334
1335 SECURITY_SERVER_API
1336 int security_server_check_privilege_by_pid(int pid, const char *object, const char *access_rights)
1337 {
1338     //This function check SMACK privilege betwen subject and object.
1339     //Subject is identified by PID number, object is function parameter.
1340
1341     int sockfd = -1;
1342     int retval;
1343     response_header hdr;
1344
1345     //check for input PID param
1346     if (pid < 0) {
1347         retval = SECURITY_SERVER_ERROR_INPUT_PARAM;
1348         goto error;
1349     }
1350
1351     SEC_SVR_DBG("%s","Check privilige by PID called");
1352     SEC_SVR_DBG("%s %d","PID", pid);
1353     SEC_SVR_DBG("%s %s", "OBJECT:", object);
1354     SEC_SVR_DBG("%s %s", "ACCESS_RIGHTS", access_rights);
1355
1356     //check if able to connect
1357     retval = connect_to_server(&sockfd);
1358     if (retval != SECURITY_SERVER_SUCCESS)
1359         goto error;
1360
1361     //send request
1362     retval = send_pid_privilege_request(sockfd, pid, object, access_rights);
1363     if (retval != SECURITY_SERVER_SUCCESS) {
1364         /* Error on socket */
1365         SEC_SVR_ERR("Client: Send failed: %d", retval);
1366         goto error;
1367     }
1368
1369     //get response
1370     retval = recv_pid_privilege_response(sockfd, &hdr);
1371
1372     //convert error code
1373     retval = return_code_to_error_code(hdr.return_code);
1374
1375     //check if frame has correct MSG_ID
1376     if (hdr.basic_hdr.msg_id != SECURITY_SERVER_MSG_TYPE_CHECK_PID_PRIVILEGE_RESPONSE) {
1377         if (hdr.basic_hdr.msg_id == SECURITY_SERVER_MSG_TYPE_GENERIC_RESPONSE) {
1378             /* There must be some error */
1379             SEC_SVR_ERR("Client: Error has been received. return code:%d", hdr.return_code);
1380         }
1381         else {
1382             /* Something wrong with response */
1383             SEC_SVR_ERR("Client ERROR: Unexpected error occurred:%d", retval);
1384             retval = SECURITY_SERVER_ERROR_BAD_RESPONSE;
1385         }
1386         goto error;
1387     }
1388
1389     //debug info about checking result
1390
1391     if (hdr.return_code == SECURITY_SERVER_RETURN_CODE_SUCCESS) {
1392         SEC_SVR_DBG("%s","Client: There is privilege match");
1393         retval = SECURITY_SERVER_SUCCESS;
1394     } else {
1395         SEC_SVR_ERR("%s","Client: There is no privilege match");
1396         retval = SECURITY_SERVER_ERROR_ACCESS_DENIED;
1397     }
1398
1399 error:
1400     if(sockfd > 0)
1401         close(sockfd);
1402
1403     retval = convert_to_public_error_code(retval);
1404     return retval;
1405 }