vmodem/server/client.c

   1 /*
   2  *  telephony-emulator
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  * Sooyoung Ha <yoosah.ha@samsung.com>
   8  * Sungmin Ha <sungmin82.ha@samsung.com>
   9  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
  10  *
  11  * This library is free software; you can redistribute it and/or modify it under
  12  * the terms of the GNU Lesser General Public License as published by the
  13  * Free Software Foundation; either version 2.1 of the License, or (at your option)
  14  * any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful, but WITHOUT ANY
  17  * WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
  19  * License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * along with this library; if not, write to the Free Software Foundation, Inc., 51
  23  * Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  24  *
  25  * Contributors:
  26  * - S-Core Co., Ltd
  27  *
  28  */
  29
  30 #include <stdlib.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <assert.h>
  34 #include "gsmstate.h"
  35 #include "phoneprotocol4gsm.h"
  36 #include "vgsm_phone.h"
  37 #include "vgsm_ss.h"
  38 // #include <mzgsmsat.h>
  39 // #include <mzgsmsound.h>
  40 #include "vgsm_sms.h"
  41 #include "vgsm_gprs.h"
  42 #include "db_gprs.h"
  43 #include "logmsg.h"
  44
  45 #include "phoneserver.h"
  46 #include "at_tx_func.h"
  47 #include "at_rx_func.h"
  48 #include "misc.h"
  49 #include "at_send.h"
  50 #include "at_tx_sms.h"
  51 #include "state.h"
  52
  53 //#include "db_phonebook.h"
  54 #include "server_common_security.h"
  55 #include "server_common_network.h"
  56 #include "vgsm_sim.h"
  57 #include "server_tx_security.h"
  58 #include "server_tx_phonebook.h"
  59 #include "db_security.h"
  60 #include "db_phonebook.h"
  61
  62 #include "sat_util.h"
  63 #include "sat_values.h"
  64 #include "server_tx_sms.h"
  65 #include "server_tx_data.h"
  66 #include "server_tx_gprs.h"
  67
  68 #include "flight.h"
  69
  70 #include "server_tx_call.h"
  71 #include "server_common_call.h"
  72 #include "server_common_ss.h"
  73 #include "server_tx_ss.h"
  74 #include "server_tx_network.h"
  75 #include "server_tx_display.h"
  76 #include "server_tx_power.h"
  77 #include "server_client.h"
  78 /* for temporary power code. so it will be removed */
  79 #include "at_msg.h"
  80 #include "vgsm_phone.h"
  81 /* end */
  82 #include <vconf/vconf.h>
  83 #include <vconf/vconf-keys.h>
  84
  85 #define MAX_RESULT_LENGTH 1024
  86
  87 GSM_Device_Functions            * Device;
  88 int                     smsSentStatus = 0;
  89
  90 extern GSM_StateMachine           GlobalS;
  91
  92 #define MMI_SC_LENGTH2          14
  93 #define MMI_SC_LENGTH3          10
  94
  95 #if 0
  96 static char * mmi_sc2[] =
  97 {
  98     "21", // CFU
  99     "67", // CF Busy
 100     "61", // CF No Reply
 101     "62", // CF Not Reachable
 102     "43", // Call Waiting
 103     "30", // CLIP
 104     "31", // CLIR
 105     "76", // COLP
 106     "77", // COLR
 107     "33", // CB, all outgoing
 108     "35", // CB, all incoming"
 109     "03", // CB, change of password
 110     "04", // Change PIN1
 111     "05"  // Change PUK1
 112 };
 113
 114 static char * mmi_sc3[] =
 115 {
 116     "331",// CB, outgoing int'l
 117     "332",// CB, outgoing int'l except HOME
 118     "351",// CB, incoming Roaming
 119     "330",// CB, all calls
 120     "333",// CB, all outgoing
 121     "353",// CB, all incoming
 122     "002",// All CF
 123     "004",// All Conditional CF
 124     "042",// Change PIN2
 125     "052" // Change PUK2
 126 };
 127
 128 static bool isUSSD(char * data)
 129 {
 130     // ** : register and activate
 131         // *  : activate
 132         // *# : interrogate
 133         // #  : deactivate
 134         // ## : de-register (and de-activate)
 135
 136     int start = 0;
 137     int ii;
 138
 139     if  (data[0] == '*' && data[1] == '*') // register and activate
 140         start = 2;
 141     else
 142     if  (data[0] == '*' && (data[1] != '*' && data[1] != '#') ) // activate
 143         start = 1;
 144     else
 145     if  (data[0] == '*' && data[1] == '#') // interrogate
 146         start = 2;
 147     else
 148     if  (data[0] == '#' && (data[1] != '#' && data[1] != '*')) // deactivate
 149         start = 1;
 150     else
 151     if  (data[0] == '#' && data[1] == '#')  // de-register (and deactivate)
 152         start = 2;
 153     else
 154         TRACE(MSGL_WARN, "Warning : Bad MMI code <%s>\n", data);
 155
 156     for (ii = 0; ii < MMI_SC_LENGTH2; ii ++)
 157     {
 158         if  (strncmp( (const char *)&data[start], mmi_sc2[ii], 2) == 0) // Normal SS SC
 159             return false;
 160     }
 161
 162     for (ii = 0; ii < MMI_SC_LENGTH3; ii ++)
 163     {
 164         if  (strncmp( (const char *)&data[start], mmi_sc3[ii], 3) == 0) // Normal SS SC
 165             return false;
 166     }
 167
 168     return true;
 169 }
 170 #endif
 171
 172 #if 0
 173 void do_ext(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 174 {
 175     int action = packet->action;
 176     int length = packet->length;
 177     int klass = ci->klass;
 178
 179     char * p = (char *)(packet->data);
 180     switch (action)
 181     {
 182         case GSM_EXT_SET_INTERNAL_STATE_REQ :
 183             {
 184                 LXT_PHONE_STATE state = (LXT_PHONE_STATE)p[0];
 185                 TRACE(MSGL_VGSM_INFO, "## GSM_EXT_SET_INTERNAL_STATE_REQ %d\n",
 186                                                                 (int)state);
 187                 FuncPhoneServer->BroadcastInternalStatus( &GlobalPS,
 188                         state);
 189             }
 190             break;
 191
 192         case GSM_EXT_SET_AUDIO_PATH_REQ :
 193                         break;
 194         case GSM_EXT_SET_VOICE_VOL_REQ :
 195                         break;
 196         case GSM_EXT_SET_IMEI_REQ :
 197                         break;
 198                 case GSM_EXT_SET_BTMAC_REQ :
 199                         break;
 200                 case GSM_EXT_GET_BTMAC_REQ :
 201                         break;
 202         }
 203 }
 204
 205
 206 #endif /* 0 */
 207
 208 // 090326               // restore data in EI
 209 static void do_restore_ei(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 210 {
 211         unsigned char data[MAX_GSM_DIALED_DIGITS_NUMBER+4];
 212
 213         log_msg(MSGL_VGSM_INFO,"do_restore_EI\n");
 214
 215         init_ss_info_re();
 216         init_plmn_list();
 217         server_sim_db_init();
 218
 219         gsm_call_list_t * callList = malloc(sizeof(gsm_call_list_t));
 220         LXT_MESSAGE MOpacket;
 221         TAPIMessageInit(&MOpacket);
 222         int i = 0;
 223
 224         get_call_list(callList);
 225
 226         for( i=0; i<MAX_CALL_COUNT; ++i )
 227         {
 228                 if(callList->CallInfo[i].stat == GSM_CALL_STATUS_DIALING || callList->CallInfo[i].stat == GSM_CALL_STATUS_ALERT)
 229                 {
 230                         data[0] = callList->CallInfo[i].idx;
 231                         data[1] = callList->CallInfo[i].call_type;
 232                         data[2] = callList->CallInfo[i].num_len;
 233                         data[3] = callList->CallInfo[i].stat;
 234
 235                         memset(&data[4], 0, MAX_GSM_DIALED_DIGITS_NUMBER);
 236                         memcpy(&data[4], callList->CallInfo[i].number, callList->CallInfo[i].num_len);
 237                         MOpacket.data = data;
 238                         MOpacket.group  = GSM_CALL;
 239                         MOpacket.action = GSM_CALL_MAKE_REQ;
 240                         MOpacket.length = callList->CallInfo[i].num_len + 4;
 241
 242                         FuncServer->Cast(&GlobalPS, LXT_ID_CLIENT_EVENT_INJECTOR, &MOpacket);
 243                 }
 244         }
 245
 246         free(callList);
 247         callback_callist();
 248
 249         log_msg(MSGL_VGSM_INFO,"do_restore_EI\n");
 250 }
 251
 252 static void do_sat(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 253 {
 254
 255     int action = packet->action;
 256 //    char * p = (char *)(packet->data);
 257
 258     DP_TEXT *dp_text;
 259     GET_INKEY *get_inkey;
 260     GET_INPUT *get_input;
 261
 262         TRACE(MSGL_VGSM_INFO, "%x\n", action);
 263     switch (action)
 264         {
 265         case GSM_SAT_PROACTIVE_DISPLAY_TEXT     :
 266                 {
 267                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_DISPLAY_TEXT\n");
 268
 269                         dp_text = (DP_TEXT *)(packet->data);
 270                         Display_Text(dp_text);
 271                         break;
 272                 }
 273
 274         case GSM_SAT_PROACTIVE_GET_INKEY:
 275                 {
 276                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_GET_INKEY\n");
 277                         get_inkey = (GET_INKEY *)(packet->data);
 278                         Get_Inkey(get_inkey);
 279                         break;
 280                 }
 281
 282         case GSM_SAT_PROACTIVE_GET_INPUT:
 283                 {
 284                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_GET_INPUT\n");
 285                         get_input = (GET_INPUT *)(packet->data);
 286                         Get_Input(get_input);
 287                         break;
 288                 }
 289
 290         case GSM_SAT_PROACTIVE_SET_MENU:
 291                 {
 292                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_SET_MENU\n");
 293                         Set_Menu(packet->data);
 294                         break;
 295                 }
 296
 297         case GSM_SAT_PROACTIVE_SELECT_ITEM:
 298                 {
 299                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_SELECT_ITEM\n");
 300                         Select_Item(packet->data);
 301                         break;
 302                 }
 303         case GSM_SAT_PROACTIVE_SEND_SMS:
 304                 {
 305                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_SEND_SMS\n");
 306                         Send_SMS(packet->data);
 307                         break;
 308                 }
 309         case GSM_SAT_PROACTIVE_SET_UP_CALL:
 310                 {
 311                         log_msg(MSGL_VGSM_INFO,"Client - GSM_SAT_PROACTIVE_SET_UP_CALL\n");
 312                         Set_Up_Call(packet->data);
 313                         break;
 314                 }
 315
 316         #if 0
 317         case GSM_SAT_ENVELOPE_COMMAND_REQ:
 318             {
 319                         GSM_SatEnvelopeCmd cmd;
 320
 321                         cmd.length = length;
 322                         cmd.cmd = p;
 323                         TxSAT_ExecEnvelopeCommand(&cmd);
 324                 }
 325                 break;
 326         case GSM_SAT_PROFILE_DOWNLOAD_SET:
 327             {
 328                         GSM_SatProfileDown cmd;
 329
 330                         cmd.result_code = length;
 331                         memcpy(cmd.usat_profile, p, 20);
 332                         TxSAT_SetProfileDownload(&cmd);
 333                 }
 334                 break;
 335         case GSM_SAT_TERMINATE_SESSION_SET:
 336             {
 337                         TxSAT_SetTerminateUSATSession(p);
 338                 }
 339                 break;
 340         case GSM_SAT_PROVIDE_LOCAL_INFOMATION_GET:
 341             {
 342                         unsigned char infoType;
 343                         infoType = *p;
 344                         TxSAT_GetProvideLocalInfo(infoType);
 345                 }
 346                 break;
 347         case GSM_SAT_POLLING_GET:
 348             {
 349                         GSM_SatPollingGetType cmd;
 350                         cmd.pollReqType = *p++;
 351                         cmd.present = *p++;
 352                         cmd.units = *p++;
 353                         cmd.value = *p;
 354                         TxSAT_GetPolling(&cmd);
 355                 }
 356                 break;
 357         case GSM_SAT_REFRESH_GET:
 358             {
 359                         GSM_SatRefreshGetType cmd;
 360                         cmd.refreshMode = *p++;
 361                         cmd.numOfFile = *p++;
 362                         cmd.filePathLength = *p++;
 363                         memcpy(cmd.fullFilePath, p, 256);
 364                         p += 256;
 365                         cmd.aidPresent = *p++;
 366                         memcpy(cmd.aid, p, 16);
 367                         TxSAT_GetRefresh(&cmd);
 368                 }
 369                 break;
 370         case GSM_SAT_SETUP_EVENT_LIST_GET:
 371             {
 372                         GSM_SatEventListGetType cmd;
 373                         cmd.length = *p++;
 374                         memcpy(cmd.eventList, p, 17);
 375                         TxSAT_GetSetupEventList(&cmd);
 376                 }
 377                 break;
 378                 #endif
 379
 380         default :
 381                 break;
 382         }
 383 }
 384
 385 static void do_data(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 386 {
 387     TRACE(MSGL_VGSM_INFO, "\n");
 388
 389     //GSM_Error error;
 390
 391     int action = packet->action;
 392     //int length = packet->length;
 393     //int client_id = ci->klass;
 394
 395     //char * p = (char *)(packet->data);
 396     TRACE(MSGL_VGSM_INFO, "%x\n", action);
 397     switch (action)
 398     {
 399         case GSM_DATA_STATUS :
 400             server_tx_data_CallStatus(packet);
 401             break;
 402     }
 403 }
 404
 405
 406 static void preprocess_do_gprs(LXT_MESSAGE * packet)
 407 {
 408         int i, num;
 409         GprsDbEntry entry;
 410         char *pos;
 411
 412         // preprocess gprs data from evt injector
 413         char *p = (char *)(packet->data);
 414         TRACE(MSGL_VGSM_CALL, "\n");
 415         // clean up gprs db
 416         if (g_gprs_conflist.num > 0) {
 417
 418                 for (i = 0; i < g_gprs_conflist.num; i++) {
 419                         GprsDbEntry rm_entry;
 420
 421                         strcpy(rm_entry.apn, g_gprs_conflist.pentry[i].apn);
 422
 423                         vgsm_gprs_database_remove(&rm_entry);
 424                 }
 425         }
 426
 427         num = *((int *)p);
 428         if(num < 0 || num > (254 * sizeof(int)) ) {
 429                 TRACE(MSGL_VGSM_INFO, "ERROR!! Invalid value of packet.data.\n");
 430                 return;
 431         }
 432
 433         pos = p + sizeof(int);
 434
 435         for (i = 0; i < num; i++ ) {
 436                 strcpy(entry.apn, (char *)pos);
 437                 strcpy(entry.intf, (char *)(pos + 255));
 438
 439                 entry.ipconf.cid = pos[265];
 440
 441                 memcpy((char *)(&(entry.ipconf.fieldflag)), pos + 266, 2);
 442                 memcpy((char *)(entry.ipconf.ip_addr), pos + 268, 4);
 443                 memcpy((char *)(entry.ipconf.primary_dns), pos + 272, 4);
 444                 memcpy((char *)(entry.ipconf.secondary_dns), pos + 276, 4);
 445                 memcpy((char *)(entry.ipconf.default_gateway), pos + 280, 4);
 446                 memcpy((char *)(entry.ipconf.subnet_mask), pos + 284, 4);
 447
 448                 // add to gprs db
 449                 vgsm_gprs_database_add(&entry);
 450
 451                 pos += 255 + 10 + 23;
 452         }
 453
 454 }
 455
 456
 457 static void do_gprs(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 458 {
 459
 460         int action = packet->action;
 461
 462         TRACE(MSGL_VGSM_CALL, "%x\n", action);
 463         switch (action) {
 464                 case GSM_GPRS_IP_CONFIGURATION:
 465                         // process VGSM specific job
 466                         preprocess_do_gprs(packet);
 467                         server_tx_gprs_IPConfigurationNotify(packet);
 468                         break;
 469         }
 470 }
 471
 472
 473 static void do_display_indicator(const LXT_MESSAGE * packet)
 474 {
 475         const unsigned char *p;
 476
 477         assert(packet->data);
 478         assert(packet->length >= 4);
 479
 480         p = packet->data;
 481
 482         server_tx_display_icon_info_noti(p[0], p[1], p[2], p[3], GSM_NET_REG_STAT_REG_HOME);
 483 }
 484
 485 static void do_display(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 486 {
 487     TRACE(MSGL_VGSM_INFO, "\n");
 488
 489     //GSM_Error error;
 490
 491     int action = packet->action;
 492     //int length = packet->length;
 493     //int client_id = ci->klass;
 494
 495     //char * p = (char *)(packet->data);
 496         TRACE(MSGL_VGSM_CALL, "do_display %x\n", action);
 497     switch (action)
 498     {
 499         case GSM_DISPLAY_INDICATOR_NOTI :
 500                 do_display_indicator(packet);
 501             break;
 502     }
 503 }
 504
 505 static void do_power_battery_status(LXT_MESSAGE * packet)
 506 {
 507         unsigned char *p = packet->data;
 508         unsigned char level;
 509
 510         assert(packet->length >= 1);
 511         level = p[0];
 512         server_tx_battery_status_noti(level);
 513
 514         /* there seems to be two different messages that notify similar information - send both? */
 515         if (0)
 516                 server_tx_display_icon_info_noti(0x02, 0, level, 0, 0); /* only notify the battery level */
 517 }
 518
 519
 520 static void do_power(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 521 {
 522     TRACE(MSGL_VGSM_INFO, "\n");
 523
 524     int action = packet->action;
 525
 526     TRACE(MSGL_VGSM_INFO, "do_power %x\n", action);
 527
 528
 529     switch (action)
 530     {
 531         case GSM_POWER_MODEM_ON_REQ:
 532                 oem_rx_power_up_exec();
 533                 break;
 534         case GSM_POWER_BATTERY_STATUS_NOTI:
 535                 do_power_battery_status(packet);
 536                 break;
 537         default:
 538                 break;
 539     }
 540 }
 541
 542 static void do_network(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
 543 {
 544         int action = packet->action;
 545         TRACE(MSGL_VGSM_INFO, "do_network %x\n", action);
 546
 547         switch (action)
 548         {
 549                 case GSM_NETWORK_REG_NOTI:
 550                         server_tx_net_reg_noti(packet);
 551                         break;
 552
 553                 case GSM_NETWORK_PLMN_LIST:
 554                         server_tx_net_plmn_list_noti(packet);
 555                         break;
 556
 557                 case GSM_NETWORK_CURRENT_PLMN_NOTI:
 558                         server_tx_net_current_plmn_noti(packet);
 559                         break;
 560                 case GSM_NETWORK_CURRENT_NITZ_INFO:
 561                         server_tx_net_current_nitz_noti(packet);
 562                         break;
 563         }
 564 }
 565
 566
 567 static void do_sim(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
 568 {
 569         log_msg(MSGL_VGSM_ERR,"\n");
 570
 571         int action = packet->action;
 572         int length = packet->length;
 573         int i;
 574
 575         char * p = (char *)(packet->data);
 576
 577         gsm_sec_lock_e_type type;
 578         gsm_sec_status_type status;
 579         gsm_sec_lock_mode_e_type flag;
 580
 581         char *password = NULL;
 582         PB * pb;
 583
 584         STATE current;
 585
 586         get_current_state_machine( &current );
 587        TRACE(MSGL_VGSM_INFO, "do_sim %x\n", action);
 588         TRACE(MSGL_VGSM_INFO, "current_state=[%x]\n\n", STATE_TYPE(current) );
 589
 590         switch (action)
 591         {
 592
 593 /************************************************************************************/
 594 /*                                                                                                                                                                      */
 595 /*                                                                      security part                                                                           */
 596 /*                                                                                                                                                                      */
 597 /************************************************************************************/
 598                 case GSM_SIM_INIT_REQ:
 599                         server_sim_db_init();
 600                break;
 601
 602             // 090602
 603                 case GSM_SIM_REINIT_REQ:
 604                         for(i=0;i<7;i++)
 605                         {
 606                        db_sim_info_add(i,NULL);
 607                        db_sim_data_add(i,NULL);
 608                         }
 609
 610                 break;
 611
 612                 case  GSM_SIM_STATUS_SET:
 613                 {
 614                         status = p[0];
 615
 616                         log_msg(MSGL_VGSM_ERR,"status=[%x]\n",status);
 617
 618                         switch(status)
 619                         {
 620                                 case GSM_SEC_STATUS_PIN_READY:
 621                                         server_sec_set_sec_status(GSM_SIM_READY);
 622                                         server_sec_reset_remain_cnt(GSM_SIM_READY);
 623                                         server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_UNLOCK);
 624                                         //server_tx_sim_sec_disable_facility();
 625                                         break;
 626
 627                                 case GSM_SEC_STATUS_PIN_REQ:
 628                                         server_sec_set_sec_status(GSM_SIM_PIN_REQ_STATE);
 629                                         server_sec_reset_remain_cnt(GSM_SIM_PIN_REQ_STATE);
 630                                         server_sec_reset_remain_cnt(GSM_SIM_PUK_REQ);
 631                                         server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 632                                         break;
 633
 634                                 case GSM_SEC_STATUS_PUK_REQ:
 635                                         server_sec_set_sec_status(GSM_SIM_PUK_REQ);
 636                                         server_sec_set_cnt_zero(GSM_SIM_PIN_REQ_STATE);
 637                                         server_sec_reset_remain_cnt(GSM_SIM_PUK_REQ);
 638                                         server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 639                                         break;
 640
 641                                 case GSM_SEC_STATUS_PIN2_REQ:
 642                                         server_sec_set_sec2_status(GSM_SIM_PIN2_REQ);
 643                                         server_sec_reset_remain_cnt(GSM_SIM_PIN2_REQ);
 644                                         server_sec_reset_remain_cnt(GSM_SIM_PUK2_REQ);
 645                                         //server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 646                                         break;
 647
 648                                 case GSM_SEC_STATUS_PUK2_REQ:
 649                                         server_sec_set_sec2_status(GSM_SIM_PUK2_REQ);
 650                                         server_sec_set_cnt_zero(GSM_SIM_PIN2_REQ);
 651                                         server_sec_reset_remain_cnt(GSM_SIM_PUK2_REQ);
 652                                         //server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 653                                         break;
 654
 655                                 case GSM_SEC_STATUS_PERM_BLOCKED:
 656                                         server_sec_set_sec_status(GSM_SIM_FRIZEN);
 657                                         server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 658                                         break;
 659
 660                                 case GSM_SEC_STATUS_NO_SIM:
 661                                         server_sec_set_sec_status(GSM_SIM_NO_SIM);
 662                                         server_sec_set_facility(GSM_SIM_FACILITY_PIN, GSM_SEC_LOCK_MODE_LOCK);
 663                                         break;
 664
 665                                 case GSM_SEC_STATUS_PIN2_READY:
 666                                         server_sec_set_sec2_status(GSM_SIM_PIN2_OK);
 667                                         server_sec_reset_remain_cnt(GSM_SIM_PIN2_OK);
 668                                         break;
 669
 670                                 default :
 671                                         log_msg(MSGL_VGSM_ERR,"ERROR -Not handled status =[%d] in sim status set \n", status);
 672                                         break;
 673                         }
 674                 }
 675                 break;
 676
 677                 case GSM_SIM_CHANGE_PASS_SET :
 678                 {
 679                         type = p[0];
 680                         password = malloc(length-1);
 681                         if(!password)
 682                                 return;
 683                         memcpy(password,&p[1],length-1);
 684
 685                         switch(type)
 686                         {
 687                                 case GSM_SEC_LOCK_TYPE_SC:
 688                                         server_sec_change_password(password,GSM_SIM_PIN_REQ_STATE,length-1);
 689                                         break;
 690
 691                                 case GSM_SEC_LOCK_TYPE_SC2:
 692                                         server_sec_change_password(password,GSM_SIM_PIN2_REQ,length-1);
 693                                         break;
 694 #if 1                                                                                                                                                                                   // 090215
 695                 case GSM_SEC_LOCL_TYPE_PUK:
 696                     server_sec_change_password(password,GSM_SIM_PUKSET_REQ,length-1);
 697                     break;
 698                 case GSM_SEC_LOCL_TYPE_PUK2:
 699                     server_sec_change_password(password,GSM_SIM_PUK2SET_REQ,length-1);
 700                     break;
 701 #endif
 702
 703                                 default :
 704                                         log_msg(MSGL_VGSM_ERR,"ERROR -Not handled type =[%d] in change pw \n", type);
 705                                         break;
 706                         }
 707                 }
 708                 break;
 709
 710                 case GSM_SIM_FACILITY_SET:
 711                 {
 712                         type = p[0];
 713                         flag =  p[1];
 714
 715                         log_msg(MSGL_VGSM_ERR,"GSM_SIM_FACILITY_SET - type, flag = [%d],[%d]\n", type, flag);
 716
 717                 if(type == GSM_SEC_LOCK_TYPE_SC)
 718                         {
 719                                 server_sec_set_facility(GSM_SIM_FACILITY_PIN,flag);
 720                         }
 721                 else if( type == GSM_SEC_LOCK_TYPE_FD)
 722                         {
 723                                 server_sec_set_facility(GSM_SIM_FACILITY_FDN,flag);
 724                         }
 725                         else
 726                         {
 727                                 log_msg(MSGL_VGSM_ERR,"ERROR - Not handled type =[%d] in facility set \n", type);
 728                         }
 729                 }
 730                 break;
 731
 732                 case GSM_SIM_GET_SIM_DB_REQ:
 733                 {
 734                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_GET_SIM_DB_REQ\n");
 735                         db_sim_sec_restore(VGSM_SIMTypeget);
 736                 }
 737                 break;
 738
 739                 case GSM_SIMINFO_REQ:
 740                 {
 741                         int *list;
 742                         char table[10];
 743
 744                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIMINFO_REQ\n");
 745                         list = (int*)packet->data;
 746                         log_msg(MSGL_VGSM_ERR,"list : %d\n",*list);
 747
 748                         switch(*list)
 749                         {
 750                                 case 0:
 751                                         strcpy(table, "Tusim_li");
 752                                 break;
 753                                 case 1:
 754                                         strcpy(table, "Tecc");
 755                                 break;
 756                                 case 2:
 757                                         strcpy(table, "Tsst");
 758                                 break;
 759                                 case 3:
 760                                         strcpy(table, "Test");
 761                                 break;
 762                                 case 4:
 763                                         strcpy(table, "Tcphs");
 764                                 break;
 765                                 case 5:
 766                                         strcpy(table, "Tspn");
 767                                 break;
 768                                 case 6:
 769                                         strcpy(table, "Timsi");
 770                                 break;
 771                         }
 772                         db_sim_info_restore(table);
 773                 }
 774                 break;
 775
 776                 case GSM_SIMDATA_REQ:
 777                 {
 778                         int *list;
 779                         char table[10];
 780
 781                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIMDATA_REQ\n");
 782                         list = (int*)packet->data;
 783                         log_msg(MSGL_VGSM_ERR,"list : %d\n",*list);
 784
 785                         switch(*list)
 786                         {
 787                                 case 0:
 788                                         strcpy(table, "Ticcid");
 789                                 break;
 790                                 case 1:
 791                                         strcpy(table, "Tusim_li");
 792                                 break;
 793                                 case 2:
 794                                         strcpy(table, "Tecc");
 795                                 break;
 796                                 case 3:
 797                                         strcpy(table, "Tsst");
 798                                 break;
 799                                 case 4:
 800                                         strcpy(table, "Test");
 801                                 break;
 802                                 case 5:
 803                                         strcpy(table, "Tspn");
 804                                 break;
 805                                 case 6:
 806                                         strcpy(table, "Timsi");
 807                                 break;
 808                         }
 809                         db_sim_data_restore(table);
 810                 }
 811                 break;
 812
 813                 case GSM_SIMSAVE_REQ:
 814                 {
 815                         _SIMD_t *simd_t;
 816
 817                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIMDATA_REQ\n");
 818
 819                         simd_t = (_SIMD_t*)packet->data;
 820
 821                         log_msg(MSGL_VGSM_ERR,"1. type1 : %d, type2 : %d, size : %d\n",simd_t->type1, simd_t->type2, simd_t->size);
 822                         log_msg(MSGL_VGSM_ERR,"2. data : %x, %x, %x\n",simd_t->tmp[0], simd_t->tmp[1], simd_t->tmp[2]);
 823
 824                         if(simd_t->type1 == 0)
 825                                 db_sim_info_add(simd_t->type2, simd_t);
 826                         else if(simd_t->type1 == 1)
 827                                 db_sim_data_add(simd_t->type2, simd_t);
 828                         else
 829                                 log_msg(MSGL_VGSM_ERR,"ERROR, type1 : %d, type2 : %d\n", simd_t->type1, simd_t->type2);
 830                 }
 831                 break;
 832
 833
 834 /************************************************************************************/
 835 /*                                                                                                                                                                      */
 836 /*                                                                      Phonebook part                                                                  */
 837 /*                                                                                                                                                                      */
 838 /************************************************************************************/
 839
 840                 case GSM_SIM_MAKE_PB_DB_REQ:
 841                 {
 842                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_MAKE_PB_DB_REQ\n");
 843                         db_sim_pb_create();
 844                 }
 845                 break;
 846
 847                 case GSM_SIM_ADD_PB_DB_REQ:
 848                 {
 849                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_ADD_PB_DB_REQ\n");
 850
 851                         pb = (PB *)(packet->data);
 852                         db_sim_pb_set_mgr(pb->db_st_type,1);
 853
 854                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_ADD_PB_DB_REQ : %d , %s ,%s, %s\n",pb->db_st_type,pb->name,pb->number,pb->address);
 855
 856                         db_sim_pb_add(pb);
 857                         db_sim_pb_restore(pb);
 858
 859                 }
 860                 break;
 861
 862                 case GSM_SIM_GET_PB_DB_REQ:
 863                 {
 864                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_GET_PB_DB_REQ\n");
 865
 866                         pb = (PB *)(packet->data);
 867
 868                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_GET_PB_DB_REQ : %d , %s \n",pb->db_st_type,pb->name);
 869
 870                         db_sim_pb_get(pb);
 871                         db_sim_pb_restore(pb);
 872                 }
 873                 break;
 874
 875                 case GSM_SIM_DELETE_PB_DB_REQ:
 876                 {
 877                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_DELETE_PB_DB_REQ\n");
 878
 879                         pb = (PB *)(packet->data);
 880                         db_sim_pb_set_mgr(pb->db_st_type,1);
 881
 882                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_DELETE_PB_DB_REQ : %d , %s \n",pb->db_st_type,pb->name);
 883
 884                         db_sim_pb_remove(pb);
 885                         db_sim_pb_restore(pb);
 886                 }
 887                 break;
 888
 889                 case GSM_SIM_GET_ALL_PB_DB_REQ:
 890                 {
 891                         log_msg(MSGL_VGSM_ERR,"action ->GSM_SIM_GET_ALL_PB_DB_REQ\n");
 892
 893                         pb = (PB *)(packet->data);
 894                         //db_sim_pb_set_mgr(pb->db_st_type,1);
 895
 896                         db_sim_pb_restore(pb);
 897                 }
 898                 break;
 899
 900                 default:
 901                         log_msg(MSGL_VGSM_ERR,"ERROR - Not handled action =[%x] \n", action);
 902                 break;
 903         }
 904         if(password)
 905                 free(password);
 906 }
 907
 908
 909 static void do_sups(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
 910 {
 911     int action = packet->action;
 912     TRACE(MSGL_VGSM_INFO, "do_sups %x\n", action);
 913
 914     switch (action)
 915     {
 916     case GSM_SUPS_CONFERENCE:
 917         server_tx_ss_state( SS_STATE_CONFERENCE );
 918         break;
 919     case GSM_SUPS_HOLD:
 920         server_tx_ss_state( SS_STATE_HOLD );
 921         break;
 922     case GSM_SUPS_UNHOLD:
 923         server_tx_ss_state( SS_STATE_UNHOLD );
 924         break;
 925
 926     case GSM_SUPS_SET_CW_REQ :
 927         server_tx_ss_cw_set_req( packet);
 928             break;
 929
 930     case GSM_SUPS_SET_CCFC_REQ:
 931         server_tx_ss_ccfc_set_req(packet);
 932             break;
 933
 934     case GSM_SUPS_SET_CB_REQ:
 935         server_tx_ss_cb_set_req(packet);
 936             break;
 937 #if 1
 938         case GSM_SUPS_AOC_GET:
 939                 server_tx_ss_aoc_get_req(packet);
 940         break;
 941         case GSM_SUPS_AOC_SET:
 942                 server_tx_ss_aoc_set_req(packet);
 943         break;
 944 #endif
 945         // 090330 090406 //////////////////////////////////////////////
 946         case GSM_SUPS_CW_SET:
 947                 server_tx_ss_cw_set_req(packet);
 948         break;
 949
 950         /*
 951         case GSM_SUPS_CW_GET:
 952                 server_tx_ss_cw_get_req(packet);
 953         break;
 954         */
 955
 956         case GSM_SUPS_CF_SET:
 957                 server_tx_ss_cf_set_req(packet);
 958         break;
 959
 960         /*
 961         case GSM_SUPS_CF_GET:
 962                 server_tx_ss_cf_get_req(packet);
 963         break;
 964         */
 965
 966         case GSM_SUPS_CB_SET:
 967                 server_tx_ss_cb_set_req(packet);
 968         break;
 969
 970         /*
 971         case GSM_SUPS_CB_GET:
 972                 server_tx_ss_cb_get_req(packet);
 973         break;
 974         */
 975
 976         //090406//////////////////////////////////////////////////////////
 977
 978         case GSM_SUPS_USSD_SET :
 979                 server_tx_ss_ussd_set_req(packet);
 980         break;
 981
 982         case GSM_SUPS_USSD_GET :
 983                 server_tx_ss_ussd_get_req(packet);
 984         break;
 985
 986         default :
 987                   TRACE(MSGL_VGSM_INFO, "do_sups no handle = %x\n", action);
 988     }
 989 }
 990
 991 static void do_emulator(PhoneServer * ps,
 992                 TClientInfo * ci, LXT_MESSAGE * packet)
 993 {
 994     int action = packet->action;
 995
 996     TRACE(MSGL_VGSM_INFO, "do_emulator %x\n", action);
 997     switch (action)
 998     {
 999         case GSM_EMULATOR_HDLC_REQ:
1000             ATTxEmulator_HDLC_Req(packet);
1001             break;
1002         case GSM_EMULATOR_HDLC_MODE:
1003             ATTxEmulator_HDLC_Mode(packet);
1004             break;
1005         case GSM_EMULATOR_HDLC_CLEAR:
1006             ATTxEmulator_HDLC_Clear();
1007             break;
1008         case GSM_EMULATOR_SET_CALL_GENERAL_RESPONSE_ERROR:
1009             ATTxEmulator_Set_General_Response_Error(packet);
1010             break;
1011         case GSM_EMULATOR_SET_SS_GENERAL_RESPONSE_ERROR:
1012             ATTxEmulator_Set_SS_General_Response_Error(packet);
1013             break;
1014         case GSM_EMULATOR_SET_CALL_STATUS_ERROR:
1015             ATTxEmulator_Set_Call_Status_Error(packet);
1016             break;
1017         case GSM_EMULATOR_SET_SCA:
1018             ATTxEmulator_Set_SCA(packet);
1019             break;
1020 // ss error cause set
1021         case GSM_EMULATOR_SET_SS_HOLD_RESPONSE_ERROR:
1022         case GSM_EMULATOR_SET_SS_RETRIEVE_RESPONSE_ERROR:
1023         case GSM_EMULATOR_SET_SS_JOIN_RESPONSE_ERROR:
1024         case GSM_EMULATOR_SET_SS_SPLIT_RESPONSE_ERROR:
1025         case GSM_EMULATOR_SET_SS_TRANSFER_RESPONSE_ERROR:
1026             ATTxEmulator_Set_SS_Response_Error(packet, action);
1027             break;
1028     }
1029 }
1030
1031 static void do_client(PhoneServer * ps,
1032                 TClientInfo * ci, LXT_MESSAGE * packet)
1033 {
1034     int action = packet->action;
1035
1036     TRACE(MSGL_VGSM_INFO, "do_client %x\n", action);
1037     switch (action)
1038     {
1039         case GSM_CLIENT_RELEASE_NOTI:
1040             server_client_release_noti();
1041             break;
1042     }
1043 }
1044
1045
1046 static void do_sms(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
1047 {
1048         unsigned char *p;
1049     int action = packet->action;
1050     char vconf_cmd[99];
1051
1052     TRACE(MSGL_VGSM_INFO, "do_sms %x\n", action);
1053     switch (action)
1054     {
1055         case GSM_SMS_SEND_MSG_REQ:
1056                 server_tx_sms_notiIncomingMsg(packet);
1057                 break;
1058         case GSM_SMS_SEND_ACK_REQ:
1059                 p = (unsigned char *)packet->data;
1060                 smsSentStatus = (int)p[0];
1061                 if(smsSentStatus == 10 || smsSentStatus == 11){
1062                     sprintf(vconf_cmd, "vconftool set -t int memory/telephony/mms_sent_status %d -i -f", (smsSentStatus - 10));
1063                     TRACE(MSGL_VGSM_INFO, "system : %s\n", vconf_cmd);
1064                     system(vconf_cmd);
1065                 }
1066
1067                 server_tx_sms_ReceiveAckMsg(packet);
1068                 break;
1069         case GSM_SMS_INCOMING_CB_MSG_REQ:
1070                 server_tx_sms_NotiIncomingCBMsg(packet);
1071                 break;
1072 #if 0
1073                 case GSM_SMS_SEND_MSG_REQ:
1074                         TxSMS_ExecSendMsg(packet);
1075                         break;
1076                 case GSM_SMS_READ_MSG_REQ:
1077                         TxSMS_GetReadMsg(packet);
1078                         break;
1079                 case GSM_SMS_SAVE_MSG_REQ:
1080                         TxSMS_ExecSaveMsg(packet);              // by luxmea
1081                         break;
1082                 case GSM_SMS_DEL_MSG_REQ:
1083                         TxSMS_ExecDeleteMsg(packet);
1084                         break;
1085                 case GSM_SMS_SEND_ACK_REQ:
1086                         TxSMS_SetSendAck(packet);
1087                         break;
1088                 case GSM_SMS_GET_SEL_MEM_REQ:
1089                         TxSMS_GetSelectMem(packet);
1090                         break;
1091                 case GSM_SMS_SET_SEL_MEM_REQ:
1092                         TxSMS_SetSelectMem(packet);
1093                         break;
1094                 case GSM_SMS_STORED_MSG_CNT_REQ:
1095                         TxSMS_GetStoredMsgCount(packet);
1096                         break;
1097                 case GSM_SMS_GET_MSG_CONFIG_REQ:
1098                         TxSMS_GetMsgConfig(packet);
1099                         break;
1100                 case GSM_SMS_SET_MSG_CONFIG_REQ:
1101                         TxSMS_SetMsgConfig(packet);
1102                         break;
1103                 case GSM_SMS_GET_SVC_OPTION_REQ:
1104                         TxSMS_GetSvcOption(packet);
1105                         break;
1106                 case GSM_SMS_SET_SVC_OPTION_REQ:
1107                         TxSMS_SetSvcOption(packet);
1108                         break;
1109                 case GSM_SMS_MEM_FULL_REQ:
1110                         TxSMS_SetMemFull(packet);
1111                         break;
1112         case GSM_SMS_GET_CB_CONFIG_REQ:
1113             TxSMS_GetCBConfig(packet);
1114             break;
1115         case GSM_SMS_SET_CB_CONFIG_REQ:
1116             TxSMS_SetCBConfig(packet);
1117             break;
1118         case GSM_SMS_SET_MSG_STATUS_REQ:
1119             TxSMS_SetMsgStatus(packet);
1120             break;
1121         case GSM_SMS_SET_BLK_LIST_REQ:
1122             TxSMS_SetBlkList(packet);
1123             break;
1124                 default:
1125                         TxSMS_DefaultSms(0, 0);
1126                         break;
1127 #endif /* 0 */
1128         }
1129
1130 #if 0
1131     char AT_Result[MAX_RESULT_LENGTH] = {0, };
1132
1133     memcpy(buffer, p, length);
1134
1135     error = SMSFunc->SendMessage(&GlobalS, buffer, AT_Result);
1136
1137     if  (error == ERR_TIMEOUT)
1138         TRACE(MSGL_VGSM_INFO, "MS TIMEOUT Error\n");
1139     else
1140     {
1141         FuncResponse->ResponseSMS(klass, AT_Result);
1142     }
1143 #endif
1144 }
1145
1146 #if 0
1147 static int IsFligthMode()
1148 {
1149 #ifdef __arm__
1150         int fd;
1151         fd = open("/setting/flightmode.conf\n", O_RDONLY);
1152
1153         if (fd != -1)
1154                 return 1;
1155
1156 #endif
1157         return 0;
1158 }
1159 #endif /* 0 */
1160
1161 static void do_internal(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
1162 {
1163         int klass = ci->klass;
1164         int clientfd = ci->fd;
1165         int action = packet->action;
1166         int length = packet->length;
1167
1168         TRACE(MSGL_VGSM_INFO, "do_internal %x\n", action);
1169
1170         char * p = (char *)(packet->data);
1171
1172         switch (action)
1173     {
1174         case LXT_PDA_INTERNAL_ID_REQUEST :
1175                 {
1176                         int clientid;
1177
1178                         clientid = (int)packed_S32((unsigned char *)p);
1179                         if(clientid == 0)
1180                                 TRACE(MSGL_VGSM_INFO, "ERROR!! Invalid value of clientid.\n");
1181                         ci->klass = clientid;
1182                         TRACE(MSGL_VGSM_INFO, "LXT_PDA_INTERNAL_ID_REQUEST [0x%x]: %s\n", clientid, clientName[clientid]);
1183
1184                         // nsclass : when user change language setting.
1185                         /*
1186                         if (LXT_ID_CLIENT_INDICATOR == clientid) {
1187                                 if (!IsFligthMode()) {
1188                                         if (LXT_STATE_OFF == FuncPhoneServer->GetInternalState(&GlobalPS)) {
1189                                                 GSM_PhonePowerOn(0);
1190                                         }
1191                                 }
1192                         }
1193                         */
1194                         /******************/
1195                 }
1196                 break;
1197
1198         case LXT_PDA_INTERNAL_MISSED_MESSAGE_REQUEST :
1199             {
1200                 Server * server = &ps->ServerSocket;
1201                  TRACE(MSGL_VGSM_INFO, "LXT_PDA_INTERNAL_MISSED_MESSAGE_REQUEST \n");
1202                 if  (server != NULL)
1203                 {
1204                         server->Functions->CastMissedMessage(ps, klass, clientfd);
1205                 }
1206             }
1207             break;
1208
1209         case LXT_PDA_INTERNAL_STATE_REQUEST :
1210             {
1211                  TRACE(MSGL_VGSM_INFO, "LXT_PDA_INTERNAL_MISSED_MESSAGE_REQUEST ..WARNING: it's not implemented\n");
1212                                 // nsclass : when user change language setting. phone power off sound
1213                                 /*
1214                                 if (LXT_ID_CLIENT_INDICATOR == klass) {
1215                                         if (!IsFligthMode())
1216                                                 return;
1217                                 }
1218                 FuncPhoneServer->CastCurrentInternalStatus(&GlobalPS, klass);
1219                                 */
1220                                 /******************/
1221                 break;
1222             }
1223
1224                 case LXT_PDA_INTERNAL_LAUNCH_SAT_APP_REQUEST:
1225                         {
1226                                 LXT_MESSAGE packet;
1227                                 TAPIMessageInit(&packet);
1228                                 TRACE(MSGL_VGSM_INFO, "LXT_PDA_INTERNAL_LAUNCH_SAT_APP_REQUEST\n");
1229                                 packet.group = LXT_GRP_INTERNAL;
1230                                 packet.action = LXT_PDA_INTERNAL_LAUNCH_SAT_APP_RESPONSE;
1231                                 FuncServer->Cast(&GlobalPS, LXT_ID_CLIENT_CARD_MANAGER, &packet);
1232                         }
1233                         break;
1234             case LXT_PDA_INTERNAL_SETUP_SAT_APP_REQUEST:
1235                         {
1236                                 LXT_MESSAGE packet;
1237                                 TAPIMessageInit(&packet);
1238                                 TRACE(MSGL_VGSM_INFO, "LXT_PDA_INTERNAL_SETUP_SAT_APP_REQUEST\n");
1239                                 packet.group = LXT_GRP_INTERNAL;
1240                                 packet.action = LXT_PDA_INTERNAL_SETUP_SAT_APP_RESPONSE;
1241                                 packet.length = length;
1242                                 packet.data = (void *)p;
1243                                 FuncServer->Cast(&GlobalPS, LXT_ID_CLIENT_CARD_MANAGER, &packet);
1244                         }
1245                         break;
1246
1247                 case LXT_PDA_INTERNAL_PHONE_BATTERY_REQUEST:
1248                         {
1249                                 TRACE(MSGL_VGSM_INFO, "Request phone battery\n");
1250                                 log_msg(MSGL_VGSM_INFO,"WARNING: it's not implemented \n");
1251                         }
1252                         break;
1253         default :
1254             break;
1255     }
1256 }
1257
1258 #if 0
1259 void do_power(PhoneServer* ps, TClientInfo * ci, LXT_MESSAGE * packet)
1260 {
1261     GSM_Error error;
1262
1263     int action = packet->action;
1264     int length = packet->length;
1265
1266     char * p = (char *)(packet->data);
1267
1268     switch (action)
1269     {
1270         case LXT_PDA_POWER_ON_REQUEST :
1271             /*
1272                          * Interanl state\B4\C2 \BD\C7\C1\A6 dpram event\BF\A1\BC\AD active\B8\A6 Ȯ\C0\CE\C7\D1 \C8Ŀ\A1 ó\B8\AE
1273                          */
1274                         Device->PowerOnDevice(&GlobalS, 0);
1275             break;
1276
1277         case LXT_PDA_POWER_OFF_REQUEST :
1278                         /*
1279                          *
1280                          */
1281             // FuncPhoneServer->BroadcastInternalStatus(&GlobalPS, LXT_STATE_OFF);
1282             // error = MiscFunc->PowerOff(&GlobalS);
1283             // Device->PowerOffDevice(&GlobalS);
1284
1285                         /* Phone doesn't seem to respond correctly to the Power-Off request.
1286                         After Power-Off request, we got Phone-Active signals repeatedly. civily, 2005.09.26 [
1287             TxPWR_ExecPhonePowerOff();
1288                         */ // civily, 2005.09.26 ]
1289                         TxPWR_ExecPhonePowerOff();
1290                 FuncPhoneServer->BroadcastInternalStatus(&GlobalPS, LXT_STATE_OFF);
1291                         break;
1292
1293         default :
1294             TRACE(MSGL_VGSM_INFO, "nexpected request cmd from clients 0x%02x\n", action);
1295             break;
1296     }
1297 }
1298 #endif /* 0 */
1299
1300 static void do_call(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
1301 {
1302         TRACE(MSGL_VGSM_INFO, "\n");
1303
1304     int action = packet->action;
1305     int error ;
1306
1307     TRACE(MSGL_VGSM_INFO, "do_call %x\n", action);
1308
1309         switch (action)
1310         {
1311                 case GSM_CALL_MAKE_REQ :
1312                         log_msg(MSGL_VGSM_INFO,"GSM_CALL_MAKE_REQ\n");
1313                         server_tx_call_incoming_noti(packet);
1314                         break;
1315
1316                 case GSM_CALL_HANGUP_REQ :
1317                         log_msg(MSGL_VGSM_INFO,"GSM_CALL_HANGUP_REQ\n");
1318                         server_tx_call_release_exec(packet);
1319                         break;
1320
1321                 case GSM_CALL_ANSWER_REQ :
1322                         log_msg(MSGL_VGSM_INFO,"GSM_CALL_ANSWER_REQ\n");
1323                         {
1324                                 int active = get_active_call_count();
1325                                 int hold = get_hold_call_count();
1326
1327                                 if(active >=1 && hold >= 1)
1328                                 {
1329                                         log_msg(MSGL_VGSM_INFO,"======== 1 active + 1held call ========\n");
1330                                         return ;
1331                                 }
1332                                 else if(active>=1)
1333                                 {
1334                                         log_msg(MSGL_VGSM_INFO,"======== 1 active call   ========\n");
1335                                         swap_call();
1336                                         server_tx_call_list_noti();
1337                                 }
1338                                 else
1339                                 {
1340                                         log_msg(MSGL_VGSM_INFO,"======== no established call! ========\n");
1341                                         server_tx_call_answer_exec();
1342                                 }
1343                         }
1344                         break;
1345                 case GSM_CALL_ALERT_IND:
1346                         log_msg(MSGL_VGSM_INFO,"GSM_CALL_ALERT_IND\n");
1347                         server_tx_call_alert_ind(packet->data, packet->length);
1348                         break;
1349
1350                 // 090312
1351                 case GSM_EMULATOR_SET_SS_GENERAL_RESPONSE_ERROR:
1352                         log_msg(MSGL_VGSM_INFO,"GSM_EMULATOR_SET_SS_GENERAL_RESPONSE_ERROR\n");
1353                         ATTxEmulator_Set_General_Response_Error(packet);
1354                         error = get_general_response_error();
1355                         log_msg(MSGL_VGSM_INFO,"======== Disconnect! error set  %x ========\n", error);
1356                         break;
1357
1358                 default:
1359                         assert(0);
1360         }
1361 }
1362
1363 #if 0
1364 void do_sound(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
1365 {
1366         TRACE(MSGL_VGSM_INFO, "\n" );
1367
1368     GSM_Error error;
1369
1370     int klass = ci->klass;
1371     int action = packet->action;
1372     int length = packet->length;
1373
1374     char * ptr = (char *)(packet->data);
1375
1376     switch (action)
1377     {
1378         case GSM_SND_AUDIO_PATH_CTRL_REQ:
1379                 {
1380                         GSM_SoundAudioPathType type;
1381                         type = *ptr;
1382                         TxSND_SetAudioPathCtrl(type);
1383                 }
1384                 break;
1385
1386         case GSM_SND_SET_SPKR_VOLUME_CTRL_REQ:
1387                 {
1388                         TxSND_SetVolumeCtrl(ptr[0], ptr[1]);
1389                 }
1390                 break;
1391
1392         case GSM_SND_NOTI_TONE_REQ:
1393                 {
1394                         GSM_SndNotiToneSet tone;
1395
1396                         tone.mode               = ptr[0];
1397                         tone.volume             = ptr[0];
1398                         tone.count              = ptr[0];
1399                         tone.tone_type  = ptr[0];
1400
1401                         TxSND_SetNotiTone(&tone);
1402                 }
1403                 break;
1404
1405         case GSM_SND_GET_GAIN_CTRL_REQ:
1406                 TxSND_GetGainCtrl(ptr);
1407                 break;
1408
1409         case GSM_SND_SET_GAIN_CTRL_REQ:
1410                 TxSND_ExecGainCtrl(ptr);
1411                 break;
1412
1413         case GSM_SND_SET_MIC_MUTE_CTRL_REQ:
1414                 {
1415                         GSM_SoundMuteStatusType mute;
1416
1417                         mute = *ptr;
1418                         TxSND_SetMICMuteCtrl(mute);
1419                 }
1420                 break;
1421
1422         default:
1423                 break;
1424     }
1425 }
1426
1427 void do_svcmode(PhoneServer * ps, TClientInfo * ci, LXT_MESSAGE * packet)
1428 {
1429         TRACE(MSGL_VGSM_INFO, "\n" );
1430
1431         char *ptr = (char *) packet->data;
1432
1433     switch (packet->action)
1434     {
1435         case GSM_SVCMODE_ENTER_REQ:
1436                 TxSVCMode_SetEnterServiceMode(ptr);
1437                 break;
1438
1439         case GSM_SVCMODE_END_REQ:
1440                 TxSVCMode_SetEndServiceMode(ptr[0]);
1441                 break;
1442
1443         case GSM_SVCMODE_PROCESS_KEY_REQ:
1444                 TxSVCMode_SetProcessKeyCode(ptr[0]);
1445                 break;
1446         }
1447 }
1448 #endif /* 0 */
1449
1450 static int client_callback(PhoneServer * ps, int fd, EloopCondition cond, void * data)
1451 {
1452         log_msg(MSGL_VGSM_INFO," client_callback fd=%d \n",fd);
1453         TClientInfo * ci = data;
1454
1455         LXT_MESSAGE packet;
1456         int rc = -1;
1457         int group;
1458         int action;
1459         int length;
1460         //int klass = ci->klass;
1461         int clientfd = ci->fd;
1462         int rssi = 5;
1463
1464         //unsigned char * p = 0;
1465
1466         TAPIMessageInit(&packet);
1467
1468         rc = ReadPacketBytes4(clientfd, &packet);
1469
1470         if  (rc <= 0)
1471         {
1472                 Server * server = &ps->ServerSocket;
1473                 if  (server != NULL)
1474                 {
1475                         TRACE(MSGL_VGSM_INFO, "Client was disconnected\n");
1476                         server->Functions->RemoveClient(ps, ci);
1477                 }
1478                 return -1;
1479         }
1480
1481         if  (packet.length > 0)
1482         {
1483                 packet.data = (unsigned char *) PacketDataMalloc(packet.length + 1);
1484                 rc = ReadBytes(clientfd, packet.data, packet.length);
1485                 //p = (unsigned char *)packet.data;
1486         }
1487
1488         group = packet.group;
1489         action = packet.action;
1490         length = packet.length;
1491
1492         TRACE(MSGL_VGSM_INFO, "in client_callback, group : %x\n", group);
1493
1494         if(vconf_get_int(VCONFKEY_TELEPHONY_RSSI, &rssi)) {
1495                 TRACE(MSGL_WARN, "vconf_get_int(%s) fail\n", VCONFKEY_TELEPHONY_RSSI);
1496         }
1497
1498         switch (group)
1499         {
1500         case GSM_CALL:
1501                 change_state_machine( GSM_CALL_CMD );
1502                 if( is_flight_mode() ){
1503                         TRACE(MSGL_VGSM_INFO, "Flight mode on \n");
1504                         callback_callist();
1505                 } else if(rssi == 0) {
1506                         TRACE(MSGL_VGSM_INFO, "RSSI is zero \n");
1507                         callback_callist();
1508                 } else {
1509                         TRACE(MSGL_VGSM_INFO, "Call ok \n");
1510                         do_call(ps, ci, &packet);
1511                 }
1512                 break;
1513         case GSM_NETWORK:
1514                 do_network(ps, ci, &packet);
1515                 break;
1516         case GSM_SUPS:
1517             do_sups(ps, ci, &packet);
1518             break;
1519         case GSM_SMS:
1520                 if( is_flight_mode() ){
1521                         TRACE(MSGL_VGSM_INFO, "Flight mode on \n");
1522                         sms_response_for_eventinjector();
1523                 } else if(rssi == 0) {
1524                         TRACE(MSGL_VGSM_INFO, "RSSI is zero \n");
1525                         sms_response_for_eventinjector();
1526                 } else {
1527                         TRACE(MSGL_VGSM_INFO, "SMS ok \n");
1528                         do_sms(ps, ci, &packet);
1529                 }
1530                 break;
1531         case GSM_DISPLAY:
1532         do_display(ps, ci, &packet);
1533         break;
1534         case GSM_SIM:
1535             do_sim(ps, ci, &packet);
1536             break;
1537         case GSM_DATA :
1538         do_data(ps, ci, &packet);
1539         break;
1540         case GSM_SAT:
1541                 do_sat(ps, ci, &packet);
1542                 break;
1543         case GSM_EMULATOR :
1544             do_emulator(ps, ci, &packet);
1545             break;
1546         case GSM_GPRS :
1547         do_gprs(ps, ci, &packet);
1548         break;
1549         case GSM_POWER :
1550         do_power(ps, ci, &packet);
1551         break;
1552         case GSM_CLIENT:
1553                 do_client(ps, ci, &packet);
1554                 break;
1555     case LXT_GRP_INTERNAL :
1556         do_internal(ps, ci, &packet);
1557         break;
1558         //090326
1559     case RESTORE_EI_DATA :
1560         do_restore_ei(ps, ci, &packet);
1561
1562
1563 #if 0
1564         case LXT_GRP_POWER    :
1565 /* todo : nsclass
1566                         if  (GlobalS.Phone.Data.RamDump == true)
1567             {
1568                 FuncResponse->ResponseRamDump(ci->klass);
1569                 break;
1570             }
1571 */
1572
1573             do_power(ps, ci, &packet);
1574             break;
1575
1576         case GSM_CALL      :
1577 #ifdef __arm__
1578                         if  (GlobalS.Phone.Data.PhonePower == false)
1579                 break;
1580 #endif
1581             do_call(ps, ci, &packet);
1582             break;
1583
1584         case GSM_MISC      :
1585 /* todo : nsclass
1586                         if  (GlobalS.Phone.Data.RamDump == true)
1587             {
1588                 if  (action == GSM_MISC_RAMDUMP_REQ)
1589                     do_misc(ps, ci, &packet);
1590                 else
1591                     FuncResponse->ResponseRamDump(ci->klass);
1592                 break;
1593             }
1594 */
1595
1596                         if  (GlobalS.Phone.Data.PhonePower == false)
1597                 break;
1598             do_misc(ps, ci, &packet);
1599             break;
1600
1601         case GSM_SMS       :
1602 /* todo : nsclass
1603                         if  (GlobalS.Phone.Data.RamDump == true)
1604             {
1605                 FuncResponse->ResponseRamDump(ci->klass);
1606                 break;
1607             }
1608 */
1609
1610 //                      if  (GlobalS.Phone.Data.PhonePower == false)
1611 //                break;
1612             do_sms(ps, ci, &packet);
1613             break;
1614
1615         case GSM_SUPS      :
1616 /* todo : nsclass
1617                         if  (GlobalS.Phone.Data.RamDump == true)
1618             {
1619                 FuncResponse->ResponseRamDump(ci->klass);
1620                 break;
1621             }
1622 */
1623
1624                         if  (GlobalS.Phone.Data.PhonePower == false)
1625                                   break;
1626             do_sups(ps, ci, &packet);
1627             break;
1628
1629         case GSM_SIM      :
1630 /* todo : nsclass
1631                         if  (GlobalS.Phone.Data.RamDump == true)
1632             {
1633                 FuncResponse->ResponseRamDump(ci->klass);
1634                 break;
1635             }
1636 */
1637
1638                         if  (GlobalS.Phone.Data.PhonePower == false)
1639                 break;
1640             do_sim(ps, ci, &packet);
1641             break;
1642
1643         case GSM_NETWORK  :
1644 /* todo : nsclass
1645                         if  (GlobalS.Phone.Data.RamDump == true)
1646             {
1647                 FuncResponse->ResponseRamDump(ci->klass);
1648                 break;
1649             }
1650 */
1651                         if  (GlobalS.Phone.Data.PhonePower == false)
1652                 break;
1653             do_network(ps, ci, &packet);
1654             break;
1655
1656                 case GSM_DATA :
1657 /* todo : nsclass
1658                         if  (GlobalS.Phone.Data.RamDump == true)
1659             {
1660                 FuncResponse->ResponseRamDump(ci->klass);
1661                 break;
1662             }
1663 */
1664
1665                         if  (GlobalS.Phone.Data.PhonePower == false)
1666                 break;
1667             do_data(ps, ci, &packet);
1668             break;
1669
1670                 case GSM_SOUND:
1671                         if  (GlobalS.Phone.Data.PhonePower == false)
1672                 break;
1673             do_sound(ps, ci, &packet);
1674             break;
1675
1676                 case GSM_EXT :
1677 /* todo : nsclass
1678                         if  (GlobalS.Phone.Data.RamDump == true)
1679             {
1680                 FuncResponse->ResponseRamDump(ci->klass);
1681                 break;
1682             }
1683 */
1684
1685                         if  (GlobalS.Phone.Data.PhonePower == false)
1686                 break;
1687             do_ext(ps, ci, &packet);
1688             break;
1689
1690                 case GSM_SERVICEMODE:
1691                         if  (GlobalS.Phone.Data.PhonePower == false)
1692                 break;
1693             do_svcmode(ps, ci, &packet);
1694             break;
1695
1696                 case GSM_EMULATOR :
1697 /* todo : nsclass
1698                         if  (GlobalS.Phone.Data.RamDump == true)
1699             {
1700                 FuncResponse->ResponseRamDump(ci->klass);
1701                 break;
1702             }
1703 */
1704
1705                         if  (GlobalS.Phone.Data.PhonePower == false)
1706                 break;
1707             do_emulator(ps, ci, &packet);
1708 #endif /* 0 */
1709         default :
1710             break;
1711     }
1712     TAPIMessageFree(&packet);
1713     return 1;
1714 }
1715
1716 FunctionsClient ClientHandle =
1717 {
1718     client_callback
1719 };
1720