libvmodem/libvgsm_sat.c

   1 /*
   2  *  telephony-emulator
   3  *
   4  * Copyright (c) 2000 - 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact:
   7  * Sooyoung Ha <yoosah.ha@samsung.com>
   8  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  23  *
  24  * Contributors:
  25  * - S-Core Co., Ltd
  26  *
  27  */
  28
  29 /***************************************************************************************
  30  *
  31  * File: vgsm_sat.c
  32  *
  33  * Release:
  34  *
  35  * Description: libvgsm interface.
  36  *
  37  * Revision History
  38  *
  39  ****************************************************************************************/
  40
  41 #include <string.h>
  42 #include <stdlib.h>
  43
  44 #include "lxtutil.h"
  45 #include "vgsm.h"
  46 #include "../vmodem/include/sat/sat_values.h"
  47
  48
  49 int vgsm_proactive_cmd_send(LXT_HANDLE * handle,int command)
  50 {
  51     printf("\[LIBVGSM-SIM] vgsm_proactive_cmd_send\n\n");
  52
  53     if( handle == NULL )
  54         return -1;
  55
  56     return lxt_msg_send_message(        handle->fd,
  57             GSM_SAT,
  58             GSM_SAT_PROACTIVE_COMMAND_SEND,
  59             1,
  60             (void *)(&command));
  61 }
  62
  63
  64 int vgsm_sat_display_text(LXT_HANDLE * handle,char priority,char  clear_msg,char* textstring,char coding_scheme,char icon_identifier_flag,char icon_qualifier,char* icon_identifier,char immediate_response,char duration,char duration_unit )
  65 {
  66     printf("\n vgsm_sat_display_text\n");
  67
  68     if( handle == NULL )
  69         return -1;
  70
  71     DP_TEXT *dp_text;
  72     int ret;
  73
  74     dp_text = malloc(sizeof(DP_TEXT));
  75     if(!dp_text)
  76         return -1;
  77     memset(dp_text,0,sizeof(DP_TEXT));
  78
  79     dp_text->priority                           =       priority;
  80     dp_text->clear_msg                  =       clear_msg;
  81     memcpy(dp_text->text_string,textstring,strlen(textstring));
  82     dp_text->coding_scheme              =       coding_scheme;
  83     dp_text->icon_identifier_flag               =       icon_identifier_flag;
  84     dp_text->icon_qualifier                     =       icon_qualifier;
  85     dp_text->icon_identifier                    =       0;
  86     dp_text->immediate_response =       immediate_response;
  87     dp_text->duration                           =       duration;
  88     dp_text->duration_unit                      =       duration_unit;
  89
  90     //printf("IN libvgsm - text is %s and  netxt test is %s",textstring,dp_text->text_string);
  91
  92     ret = lxt_msg_send_message
  93         (
  94          handle->fd,
  95          GSM_SAT,
  96          GSM_SAT_PROACTIVE_DISPLAY_TEXT,
  97          sizeof(DP_TEXT),
  98          dp_text
  99         );
 100
 101     if(dp_text)
 102         free(dp_text);
 103
 104     return ret;
 105 }
 106
 107
 108 int vgsm_sat_get_inkey(LXT_HANDLE * handle,char cmd_detail,char* textstring,char coding_scheme,char icon_identifier_flag,char icon_qualifier,char* icon_identifier,char immediate_response,char duration,char duration_unit )
 109 {
 110     printf("\n vgsm_sat_get_inkey\n");
 111
 112     if( handle == NULL )
 113         return -1;
 114
 115     GET_INKEY *get_inkey;
 116     int ret;
 117
 118     get_inkey = malloc(sizeof(GET_INKEY));
 119     if(!get_inkey)
 120         return -1;
 121     memset(get_inkey,0,sizeof(GET_INKEY));
 122
 123     get_inkey->cmd_detail                       =       cmd_detail;
 124     memcpy(get_inkey->text_string,textstring,strlen(textstring));
 125     get_inkey->coding_scheme            =       coding_scheme;
 126     get_inkey->icon_identifier_flag     =       icon_identifier_flag;
 127     get_inkey->icon_qualifier           =       icon_qualifier;
 128     get_inkey->icon_identifier          =       0;
 129     get_inkey->immediate_response       =       immediate_response;
 130     get_inkey->duration                 =       duration;
 131     get_inkey->duration_unit            =       duration_unit;
 132
 133     ret = lxt_msg_send_message
 134         (
 135          handle->fd,
 136          GSM_SAT,
 137          GSM_SAT_PROACTIVE_GET_INKEY,
 138          sizeof(GET_INKEY),
 139          get_inkey
 140         );
 141
 142     if(get_inkey)
 143         free(get_inkey);
 144
 145     return ret;
 146 }
 147
 148
 149 int vgsm_sat_get_input(LXT_HANDLE * handle,char cmd_detail,char* textstring,char coding_scheme,char icon_identifier_flag,char icon_qualifier,char* icon_identifier,char immediate_response,char duration,char duration_unit )
 150 {
 151     printf("\n vgsm_sat_get_input\n");
 152
 153     if( handle == NULL )
 154         return -1;
 155
 156     GET_INPUT *get_input;
 157     int ret;
 158     get_input = malloc(sizeof(GET_INPUT));
 159     if(!get_input)
 160         return -1;
 161     memset(get_input,0,sizeof(GET_INPUT));
 162
 163     get_input->cmd_detail                       =       cmd_detail;
 164     memcpy(get_input->text_string,textstring,strlen(textstring));
 165     get_input->coding_scheme            =       coding_scheme;
 166     get_input->icon_identifier_flag     =       icon_identifier_flag;
 167     get_input->icon_qualifier           =       icon_qualifier;
 168     get_input->icon_identifier          =       0;
 169     get_input->immediate_response       =       immediate_response;
 170     get_input->duration                 =       duration;
 171     get_input->duration_unit            =       duration_unit;
 172
 173     ret = lxt_msg_send_message
 174         (
 175          handle->fd,
 176          GSM_SAT,
 177          GSM_SAT_PROACTIVE_GET_INPUT,
 178          sizeof(GET_INPUT),
 179          get_input
 180         );
 181
 182     if(get_input)
 183         free(get_input);
 184
 185     return ret;
 186 }
 187
 188
 189 int vgsm_sat_set_up_menu(LXT_HANDLE * handle,unsigned char cmd_detail,int num,void * set_up_item )
 190 {
 191     printf("\n vgsm_sat_set_up_menu \n");
 192
 193     if( handle == NULL )
 194         return -1;
 195
 196     unsigned char *data;
 197     //  int i=0;
 198     int ret=0;
 199     data = malloc(num * sizeof(SET_MENU) + 2);
 200     if(!data)
 201         return -1;
 202     memset(data,0,num *sizeof(SET_MENU) + 2);
 203
 204     data[0] =(unsigned char)num;
 205     data[1] = cmd_detail;
 206     memcpy(&data[2],(unsigned char *)set_up_item,num *sizeof(SET_MENU));
 207     printf("data num is <%x>\n",data[0]);
 208     printf("data cmd_detail is <%x>\n",data[1]);
 209
 210     ret = lxt_msg_send_message
 211         (
 212          handle->fd,
 213          GSM_SAT,
 214          GSM_SAT_PROACTIVE_SET_MENU,
 215          (num * sizeof(SET_MENU) + 2),
 216          data
 217         );
 218
 219     if(data)
 220         free(data);
 221
 222     return ret;
 223 }
 224
 225
 226 int vgsm_sat_select_item(LXT_HANDLE * handle, unsigned char cmd_detail, int num, void * set_up_item )
 227 {
 228     printf("\n vgsm_sat_select_item \n");
 229
 230     if( handle == NULL )
 231         return -1;
 232
 233     unsigned char *data;
 234     //  int i=0;
 235     int ret=0;
 236     data = malloc(num * sizeof(SET_MENU) + 2);
 237     if(!data)
 238         return -1;
 239     memset(data,0,num *sizeof(SET_MENU) + 2);
 240
 241     data[0] =(unsigned char)num;
 242     data[1] = cmd_detail;
 243     memcpy(&data[2],(unsigned char *)set_up_item,num *sizeof(SET_MENU));
 244
 245     printf("data num is <%x>\n",data[0]);
 246     printf("data cmd_detail is <%x>\n",data[1]);
 247
 248     ret = lxt_msg_send_message
 249         (
 250          handle->fd,
 251          GSM_SAT,
 252          GSM_SAT_PROACTIVE_SELECT_ITEM,
 253          (num * sizeof(SET_MENU) + 2),
 254          data
 255         );
 256
 257     if(data)
 258         free(data);
 259
 260     return ret;
 261 }
 262
 263
 264 int vgsm_sat_send_sms(LXT_HANDLE * handle, unsigned char cmd_detail, unsigned char address, char *number, unsigned char* sms_tpdu   )
 265 {
 266     printf("\n vgsm_sat_send_sms \n");
 267
 268     if( handle == NULL )
 269         return -1;
 270
 271     //unsigned char *data;
 272     SEND_SMS *send_sms_packet;
 273     int ret=0;
 274     send_sms_packet = malloc(sizeof(SEND_SMS));
 275     if(!send_sms_packet)
 276         return -1;
 277     memset(send_sms_packet,0,sizeof(SEND_SMS));
 278
 279     send_sms_packet->cmd_detail=cmd_detail;
 280     send_sms_packet->address=address ;
 281     memcpy(send_sms_packet->dial_num,number,strlen(number));
 282     //080117 - remove compile warning msg due to sms_tpdu.
 283     memcpy(send_sms_packet->tpdu_sms,sms_tpdu,strlen((char*)sms_tpdu));
 284
 285     printf("\n SMS DIAL NUM is %s",send_sms_packet->dial_num);
 286
 287     ret = lxt_msg_send_message
 288         (
 289          handle->fd,
 290          GSM_SAT,
 291          GSM_SAT_PROACTIVE_SEND_SMS,
 292          sizeof(SEND_SMS),
 293          send_sms_packet
 294         );
 295
 296     if(send_sms_packet)
 297         free(send_sms_packet);
 298
 299     return ret;
 300 }
 301
 302
 303 int vgsm_sat_set_up_call(LXT_HANDLE * handle,unsigned char cmd_detail,char* dial_number,char *alpha_user,/*char *alpha_call ,*/unsigned char address,unsigned char options,char duration_unit)
 304 {
 305     printf("\n vgsm_sat_send_sms \n");
 306
 307     if( handle == NULL )
 308         return -1;
 309
 310     unsigned char *data = NULL;
 311     unsigned char *pdata = NULL;
 312     char dial_len;
 313     char alpha_user_len;
 314     //  char alpha_call_len;
 315     char size = 0;
 316     int ret=0;
 317
 318     switch(options)
 319     {
 320         case 0x00 : // not options
 321             dial_len = strlen(dial_number);
 322             size = 1+1+1+dial_len+1;
 323             data = malloc(size); // option(1) +cmd_detail(1)+dial len(1)+dial size+ address(1)
 324             memset(data,0,size);
 325
 326             pdata = data;
 327             *pdata++ = options;
 328             *pdata++ =cmd_detail ;
 329             *pdata++ = dial_len;
 330             memcpy(pdata,dial_number,dial_len);
 331             pdata += dial_len;
 332             *pdata++ = address;
 333
 334             break;
 335
 336         case 0x01: // alpha_
 337             dial_len = strlen(dial_number);
 338             alpha_user_len = strlen(alpha_user);
 339             //alpha_call_len = strlen(alpha_call);
 340             size = 1+1+1+dial_len+1+alpha_user_len+1+/*alpha_call_len+*/1;
 341             data = malloc(size); //option(1)+ cmd_detail(1)+dial len(1)+dial size+alpha_user len(1)alpha_user size++alpha_call len(1)+alpha_call size+ address(1)
 342             memset(data,0,size);
 343
 344             pdata = data;
 345             *pdata++ = options;
 346             *pdata++ =cmd_detail ;
 347
 348             *pdata++ = dial_len;
 349             memcpy(pdata,dial_number,dial_len);
 350             pdata += dial_len;
 351
 352             *pdata++ = alpha_user_len;
 353             memcpy(pdata,alpha_user,alpha_user_len);
 354             pdata += alpha_user_len;
 355
 356             /*
 357              *pdata++ = alpha_call_len;
 358              memcpy(pdata,alpha_call,alpha_call_len);
 359              pdata += alpha_call_len;
 360              */
 361             *pdata++ = address;
 362
 363
 364             break;
 365         case 0x02: // DURATION
 366             dial_len = strlen(dial_number);
 367             dial_len = strlen(dial_number);
 368             size = 1+1+1+dial_len+1+1;
 369             data = malloc(size); //option(1)+ cmd_detail(1)+dial len(1)+dial size+ address(1)+unit(1)
 370             memset(data,0,size);
 371
 372             pdata = data;
 373             *pdata++ = options;
 374             *pdata++ =cmd_detail ;
 375             *pdata++ = dial_len;
 376             memcpy(pdata,dial_number,dial_len);
 377             pdata += dial_len;
 378             *pdata++ = address;
 379             *pdata++ = duration_unit;
 380
 381
 382             break;
 383         case 0x03: //  alpha_ & DURATION
 384             dial_len = strlen(dial_number);
 385             alpha_user_len = strlen(alpha_user);
 386             //alpha_call_len = strlen(alpha_call);
 387             size = 1+1+1+dial_len+1+alpha_user_len+1+/*alpha_call_len+*/1+1;
 388             data = malloc(size); // option(1)+cmd_detail(1)+dial len(1)+dial size+alpha_user len(1)alpha_user size++alpha_call len(1)+alpha_call size+ address(1)+unit(1)
 389             memset(data,0,size);
 390
 391             pdata = data;
 392             *pdata++ = options;
 393             *pdata++ =cmd_detail ;
 394
 395             *pdata++ = dial_len;
 396             memcpy(pdata,dial_number,dial_len);
 397             pdata += dial_len;
 398
 399             *pdata++ = alpha_user_len;
 400             memcpy(pdata,alpha_user,alpha_user_len);
 401             pdata += alpha_user_len;
 402             /*
 403              *pdata++ = alpha_call_len;
 404              memcpy(pdata,alpha_call,alpha_call_len);
 405              pdata += alpha_call_len;
 406              */
 407             *pdata++ = address;
 408             *pdata++ = duration_unit;
 409
 410             printf("\n @- dial_number is %s",dial_number);
 411             printf("\n @- alpha_user is %s",alpha_user);
 412             //  printf("\n @- alpha_call is %s",alpha_call);
 413
 414             break;
 415
 416     }
 417
 418     printf("\n vgsm_sat_set_up_call \n");
 419
 420     ret = lxt_msg_send_message
 421         (
 422          handle->fd,
 423          GSM_SAT,
 424          GSM_SAT_PROACTIVE_SET_UP_CALL,
 425          size,
 426          data
 427         );
 428
 429     if(data)
 430         free(data);
 431
 432     return ret;
 433 }
 434