开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
JProvOma.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：136k
源码类别：

MTK

开发平台：

C/C++

JProvOma.c：源码内容
  1.     attr_p = root_p->attribute_list;
  3.     while (root_p != NULL)
  4.     {
  6.         if (strcmp(root_p->name, CHARACTERISTIC) == 0)
  7.         {
  8.             *nextroot_p = root_p;
  9.             return i_ret;
  10.         }
  11.         else if (strcmp(root_p->name, PARM) == 0)
  12.         {
  13.             if (strcmp(attr_p->name, NAME) == 0)
  14.             {
  15.                 UnicodeToAnsii(parm_element, (S8*) attr_p->value);
  16.                 if (strcmp(parm_element, PXAUTH_TYPE) == 0)
  17.                 {
  18.                     attr_p = attr_p->next;
  19.                     if (strcmp(attr_p->name, VALUE) == 0)
  20.                     {
  21.                         UnicodeToAnsii(parm_element, (S8*) attr_p->value);
  23.                     }
  25.                 }
  26.                 else if (strcmp(parm_element, PXAUTH_ID) == 0)
  27.                 {
  28.                     attr_p = attr_p->next;
  29.                     if (!(*logProxyData_p)->is_invalid_auth_info)
  30.                     {
  31.                         if (strcmp(attr_p->name, VALUE) == 0)
  32.                         {
  33.                             len = UCS2Strlen((S8*) attr_p->value);
  34.                             if (len >= PROV_PROFILE_USERNAME_LEN)
  35.                             {
  36.                                 len = PROV_PROFILE_USERNAME_LEN - 1;
  37.                             }
  38.                             UnicodeNToAnsii(
  39.                                 (S8*) (*logProxyData_p)->px_auth_id,
  40.                                 (S8*) attr_p->value,
  41.                                 len * ENCODING_LENGTH);
  42.                             (*logProxyData_p)->px_auth_id[len] = '';
  44.                             /* strcpy((S8*)g_ph_wap_profile_p->username,parm_element); */
  45.                         }
  46.                     }
  47.                 }
  48.                 else if (strcmp(parm_element, PXAUTH_PW) == 0)
  49.                 {
  50.                     attr_p = attr_p->next;
  51.                     if (!(*logProxyData_p)->is_invalid_auth_info)
  52.                     {
  53.                         if (strcmp(attr_p->name, VALUE) == 0)
  54.                         {
  55.                             len = UCS2Strlen((S8*) attr_p->value);
  56.                             if (len >= PROV_PROFILE_PASSWORD_LEN)
  57.                             {
  58.                                 len = PROV_PROFILE_PASSWORD_LEN - 1;
  59.                             }
  60.                             UnicodeNToAnsii(
  61.                                 (S8*) (*logProxyData_p)->px_auth_pwd,
  62.                                 (S8*) attr_p->value,
  63.                                 len * ENCODING_LENGTH);
  64.                             (*logProxyData_p)->px_auth_pwd[len] = '';
  65.                             /* strcpy((S8*)g_ph_wap_profile_p->password,parm_element); */
  66.                         }
  67.                     }
  68.                 }
  69.             }
  70.         }
  71.         root_p = root_p->next;
  72.         if (root_p != NULL)
  73.         {
  74.             attr_p = root_p->attribute_list;
  75.             if (attr_p == NULL && root_p->name == NULL)
  76.             {
  77.                 *nextroot_p = root_p;
  78.                 return i_ret;
  79.             }
  80.         }
  81.         else
  82.         {
  83.             *nextroot_p = root_p;
  84.             return i_ret;
  85.         }
  86.     }
  87.     return i_ret;
  88. }
  91. /*****************************************************************************
  92.  * FUNCTION
  93.  *  mmi_prov_oma_handle_resource_tag
  94.  * DESCRIPTION
  95.  *  This function deals with the RESOURCE characteristic tag and its PARM elements
  96.  * PARAMETERS
  97.  *  nextroot_p      [IN]        INOUT
  98.  * RETURNS
  99.  *  PROV_RETCODE
  100.  *****************************************************************************/
  101. PROV_RETCODE mmi_prov_oma_handle_resource_tag(TAG **nextroot_p)
  102. {
  103.     /*----------------------------------------------------------------*/
  104.     /* Local Variables                                                */
  105.     /*----------------------------------------------------------------*/
  107.     PROV_RETCODE i_ret = PROV_OK;
  108.     ATTRIBUTE *attr_p = NULL;
  109.     TAG *root_p;
  110.     S8 parm_element[PROV_OMA_MIN_SIZE_REQ + 1];
  111.     U8 uri[PROV_PROFILE_HOMEPAGE_URL_LEN + 1];
  112.     U32 len = 0;
  114.     /*----------------------------------------------------------------*/
  115.     /* Code Body                                                      */
  116.     /*----------------------------------------------------------------*/
  117.     root_p = *nextroot_p;
  118.     root_p = root_p->next;
  119.     attr_p = root_p->attribute_list;
  121.     /* Dara NOTE : this will be part of Browser application only & NOt MMS application */
  122.     while (root_p != NULL)
  123.     {
  124.         if (strcmp(root_p->name, CHARACTERISTIC) == 0)
  125.         {
  126.             *nextroot_p = root_p;
  127.             return i_ret;
  128.         }
  129.         else if (strcmp(root_p->name, PARM) == 0)
  130.         {
  131.             if (strcmp(attr_p->name, NAME) == 0)
  132.             {
  133.                 UnicodeToAnsii(parm_element, (S8*) attr_p->value);
  134.                 if (strcmp(parm_element, URI) == 0)
  135.                 {
  136.                     attr_p = attr_p->next;
  137.                     if (strcmp(attr_p->name, VALUE) == 0)
  138.                     {
  139.                         len = UCS2Strlen((S8*) attr_p->value);
  140.                         if (len >= PROV_PROFILE_HOMEPAGE_URL_LEN)
  141.                         {
  142.                             len = PROV_PROFILE_HOMEPAGE_URL_LEN - 1;
  143.                         }
  144.                         UnicodeNToAnsii((S8*) uri, (S8*) attr_p->value, len * ENCODING_LENGTH);
  145.                         uri[len] = '';
  146.                         // mmi_brw_add_prov_bookmark(NULL, uri);   /* Note : to add this URI in teh bookmark list */
  148.                     }
  150.                 }
  151.                 else if (strcmp(parm_element, NAME_PARM) == 0)
  152.                 {
  153.                     attr_p = attr_p->next;
  155.                 }
  156.                 else if (strcmp(parm_element, STARTPAGE) == 0)
  157.                 {
  158. // MAUI_00355388 Start
  159. mmi_prov_oma_update_wap_profile_homepage_url(uri);
  160. // MAUI_00355388 End
  161.                 }
  162.             }
  163.         }
  164.         root_p = root_p->next;
  165.         if (root_p != NULL)
  166.         {
  167.             attr_p = root_p->attribute_list;
  168.             if (attr_p == NULL && root_p->name == NULL)
  169.             {
  170.                 *nextroot_p = root_p;
  171.                 return i_ret;
  172.             }
  173.         }
  174.         else
  175.         {
  176.             *nextroot_p = root_p;
  177.             return i_ret;
  178.         }
  179.     }
  180.     return i_ret;
  182. }
  185. /*****************************************************************************
  186.  * FUNCTION
  187.  *  mmi_prov_oma_handle_csd_callspeed
  188.  * DESCRIPTION
  189.  *  This function handles CSD call speed parameter received in the OMA settings
  190.  * PARAMETERS
  191.  *  attr_p      [IN]        
  192.  * RETURNS
  193.  *  void
  194.  *****************************************************************************/
  195. void mmi_prov_oma_handle_csd_callspeed(ATTRIBUTE *attr_p)
  196. {
  197.     /*----------------------------------------------------------------*/
  198.     /* Local Variables                                                */
  199.     /*----------------------------------------------------------------*/
  201.     S8 parm_element[PROV_MIN_SIZE_REQ + 1];
  203.     /*----------------------------------------------------------------*/
  204.     /* Code Body                                                      */
  205.     /*----------------------------------------------------------------*/
  206.     if (strcmp(attr_p->name, VALUE) == 0)
  207.     {
  208.         UnicodeToAnsii(parm_element, (S8*) attr_p->value);
  210.         if (strcmp(parm_element, AUTOBAUDING) == 0 || strcmp(parm_element, "9600") == 0)
  211.         {
  212.             g_prov_set_csd_req_p->rate = CSD_PROF_RATE_9600;
  213.         }
  214.         else if (strcmp(parm_element, "4800") == 0)
  215.         {
  216.             g_prov_set_csd_req_p->rate = CSD_PROF_RATE_4800;
  217.         }
  218.         else if (strcmp(parm_element, "14400") == 0)
  219.         {
  220.             g_prov_set_csd_req_p->rate = CSD_PROF_RATE_14400;
  221.         }
  222.         else
  223.         {
  224.             g_prov_set_csd_req_p->rate = CSD_PROF_RATE_9600;
  225.         }
  226.     }
  227. }
  230. /*****************************************************************************
  231.  * FUNCTION
  232.  *  mmi_prov_oma_handle_unsupported_tag
  233.  * DESCRIPTION
  234.  *  This function handles the unsupported characteristics
  235.  * PARAMETERS
  236.  *  nextroot_p      [IN]        
  237.  * RETURNS
  238.  *  PROV_RETCODE
  239.  *****************************************************************************/
  240. PROV_RETCODE mmi_prov_oma_handle_unsupported_tag(TAG **nextroot_p)
  241. {
  242.     /*----------------------------------------------------------------*/
  243.     /* Local Variables                                                */
  244.     /*----------------------------------------------------------------*/
  246.     PROV_RETCODE i_ret = PROV_OK;
  247.     ATTRIBUTE *attr_p = NULL;
  248.     TAG *root_p;
  250.     /*----------------------------------------------------------------*/
  251.     /* Code Body                                                      */
  252.     /*----------------------------------------------------------------*/
  253.     root_p = *nextroot_p;
  254.     root_p = root_p->next;
  255.     attr_p = root_p->attribute_list;
  257.     while (root_p != NULL)
  258.     {
  260.         if (strcmp(root_p->name, CHARACTERISTIC) == 0)
  261.         {
  262.             *nextroot_p = root_p;
  263.             return i_ret;
  264.         }
  265.         else if (strcmp(root_p->name, PARM) == 0)
  266.         {
  267.             /* Do nothing ...dara */
  268.         }
  269.         root_p = root_p->next;
  270.         if (root_p != NULL)
  271.         {
  272.             attr_p = root_p->attribute_list;
  273.             if (attr_p == NULL && root_p->name == NULL)
  274.             {
  275.                 *nextroot_p = root_p;
  276.                 return i_ret;
  277.             }
  278.         }
  279.         else
  280.         {
  281.             *nextroot_p = root_p;
  282.             return i_ret;
  283.         }
  284.     }
  285.     return i_ret;
  286. }
  289. /*****************************************************************************
  290.  * FUNCTION
  291.  *  mmi_prov_oma_check_pending_application_callback
  292.  * DESCRIPTION
  293.  *  This API check if there is any pending appication settings to be installed before looking for new prov. doc
  294.  * PARAMETERS
  295.  *  void
  296.  * RETURNS
  297.  *  void
  298.  *****************************************************************************/
  299. void mmi_prov_oma_check_pending_application_callback(void)
  300. {
  301.     /*----------------------------------------------------------------*/
  302.     /* Local Variables                                                */
  303.     /*----------------------------------------------------------------*/
  305.     /*----------------------------------------------------------------*/
  306.     /* Code Body                                                      */
  307.     /*----------------------------------------------------------------*/
  308. //    GoBackHistory();/*Commented by TK*/
  309.     mmi_prov_oma_check_pending_application();
  311. }
  314. /*****************************************************************************
  315.  * FUNCTION
  316.  *  mmi_prov_oma_check_pending_application
  317.  * DESCRIPTION
  318.  *  This API check if there is any pending appication settings to be installed before looking for new prov. doc
  319.  * PARAMETERS
  320.  *  void
  321.  * RETURNS
  322.  *  void
  323.  *****************************************************************************/
  324. void mmi_prov_oma_check_pending_application(void)
  325. {
  326.     /*----------------------------------------------------------------*/
  327.     /* Local Variables                                                */
  328.     /*----------------------------------------------------------------*/
  330.     /*----------------------------------------------------------------*/
  331.     /* Code Body                                                      */
  332.     /*----------------------------------------------------------------*/
  333.     if (g_prov_dataAccountData_p != NULL)
  334.     {
  335.         jdd_MemFree(g_prov_dataAccountData_p);
  336.         g_prov_dataAccountData_p = NULL;
  337.     }
  338.     if (g_prov_appl_flag > 0)
  339.     {
  340.         if ((g_ph_cntx.profile_module == PH_BROWSER_PROV_PROFILE) && (g_prov_appl_flag & PROV_BROWSER_APPLICATION))
  341.         {
  342.             g_prov_appl_flag &= ~PROV_BROWSER_APPLICATION;
  343.             g_prov_setting_type &= ~PROV_BRS_SETTINGS;
  344.             g_ph_cntx.profile_module = PH_PROFILE_NULL;
  345.             if (g_prov_app_brw_p != NULL)
  346.             {
  347.                 jdd_MemFree(g_prov_app_brw_p);
  348.                 g_prov_app_brw_p = NULL;
  349.             }
  351.         }
  352.         else if ((g_ph_cntx.profile_module == PH_MMS_PROV_PROFILE) && (g_prov_appl_flag & PROV_MMS_APPLICATION))
  353.         {
  354.             g_prov_appl_flag &= ~PROV_MMS_APPLICATION;
  355.             g_prov_setting_type &= ~PROV_MMS_SETTINGS;
  356.             g_ph_cntx.profile_module = PH_PROFILE_NULL;
  357.             if (g_prov_app_mms_p != NULL)
  358.             {
  359.                 jdd_MemFree(g_prov_app_mms_p);
  360.                 g_prov_app_mms_p = NULL;
  361.             }
  362.         }
  363.         if (g_prov_appl_flag > 0)
  364.         {
  365.             mmi_prov_oma_show_install_application_settings_dialog();
  366.         }
  367.         else
  368.         {
  370.             mmi_prov_oma_free_napdef_info();
  371.             mmi_prov_oma_free_proxy_info();
  373.             mmi_prov_handle_get_next_prov_data();
  374.         }
  375.     }
  377. }
  380. /*****************************************************************************
  381.  * FUNCTION
  382.  *  mmi_prov_oma_show_install_application_settings_dialog
  383.  * DESCRIPTION
  384.  *  This is the entry function for the Install Settings dialogue confirmation screen
  385.  * PARAMETERS
  386.  *  void
  387.  * RETURNS
  388.  *  void
  389.  *****************************************************************************/
  390. void mmi_prov_oma_show_install_application_settings_dialog(void)
  391. {
  392.     /*----------------------------------------------------------------*/
  393.     /* Local Variables                                                */
  394.     /*----------------------------------------------------------------*/
  396.     /*----------------------------------------------------------------*/
  397.     /* Code Body                                                      */
  398.     /*----------------------------------------------------------------*/
  399.  /*   DisplayConfirm(
  400.         STR_GLOBAL_OK,
  401.         IMG_GLOBAL_OK,
  402.         STR_GLOBAL_CANCEL,
  403.         IMG_ID_PROV_CANCEL,
  404.         get_string(STR_ID_PROV_INSTALL_SETTINGS),
  405.         IMG_GLOBAL_QUESTION,
  406.         0);
  408.     SetLeftSoftkeyFunction(mmi_prov_oma_handle_install_application, KEY_EVENT_UP);
  409.     SetRightSoftkeyFunction(mmi_prov_handle_cancel, KEY_EVENT_UP);*/
  410. mmi_prov_entry_show_new_settings_popup();
  411. }
  414. /*****************************************************************************
  415.  * FUNCTION
  416.  *  mmi_prov_oma_handle_install_application
  417.  * DESCRIPTION
  418.  *  This API checks for pending Applications to be installed,show tha profile list menu for the selected application
  419.  * PARAMETERS
  420.  *  void
  421.  * RETURNS
  422.  *  PROV_RETCODE(?)
  423.  *****************************************************************************/
  424. void mmi_prov_oma_handle_install_application(void)
  425. {
  426.     /*----------------------------------------------------------------*/
  427.     /* Local Variables                                                */
  428.     /*----------------------------------------------------------------*/
  429.     PROV_RETCODE i_ret = PROV_OK;
  431.     /*----------------------------------------------------------------*/
  432.     /* Code Body                                                      */
  433.     /*----------------------------------------------------------------*/
  434.     if (g_prov_appl_flag & PROV_BROWSER_APPLICATION)
  435.     {
  436.         i_ret = mmi_prov_oma_get_application_data(g_prov_app_brw_p);
  437.         if (i_ret == PROV_OK)
  438.         {
  439.             mmi_ph_pre_entry_show_profile_list_menu(PH_BROWSER_PROV_PROFILE);
  440.         }
  441.         else
  442.         {
  443.             g_ph_cntx.profile_module = PH_BROWSER_PROV_PROFILE;
  444.             g_prov_timeout_hdlr = mmi_prov_oma_check_pending_application_callback;
  445.             PRINT_INFORMATION(("Inside mmi_prov_oma_handle_install_application for browser"));
  446.             DisplayPopupCallBack(
  447.                 (PU8) GetString(STR_ID_PROV_INVALID_SETTINGS),
  448.                 IMG_GLOBAL_ERROR,
  449.                 1,
  450.                 PROV_INVALID_SETTINGS_TIMEOUT,
  451.                 ERROR_TONE,
  452.                 g_prov_timeout_hdlr);
  453.         }
  454.     }
  455.     else if (g_prov_appl_flag & PROV_MMS_APPLICATION)
  456.     {
  457.         i_ret = mmi_prov_oma_get_application_data(g_prov_app_mms_p);
  458.         if (i_ret == PROV_OK)
  459.         {
  460.             mmi_ph_pre_entry_show_profile_list_menu(PH_MMS_PROV_PROFILE);
  461.         }
  462.         else
  463.         {
  464.             g_ph_cntx.profile_module = PH_MMS_PROV_PROFILE;
  465.             g_prov_timeout_hdlr = mmi_prov_oma_check_pending_application_callback;
  466.             PRINT_INFORMATION(("Inside mmi_prov_oma_handle_install_application for MMS"));
  467.             DisplayPopupCallBack(
  468.                 (PU8) GetString(STR_ID_PROV_INVALID_SETTINGS),
  469.                 IMG_GLOBAL_ERROR,
  470.                 1,
  471.                 PROV_INVALID_SETTINGS_TIMEOUT,
  472.                 ERROR_TONE,
  473.                 g_prov_timeout_hdlr);
  474.         }
  475.     }
  477. }
  480. /*****************************************************************************
  481.  * FUNCTION
  482.  *  mmi_prov_oma_add_napdef_info
  483.  * DESCRIPTION
  484.  *  THis API adds the napdef data into the napdef data list
  485.  * PARAMETERS
  486.  *  napdef_data_p       [IN]        INOUT
  487.  *  accountData_p       [IN]        
  488.  * RETURNS
  489.  *  void
  490.  *****************************************************************************/
  491. void mmi_prov_oma_add_napdef_info(prov_napdef_struct **napdef_data_p, prov_data_account_data_struct *accountData_p)
  492. {
  493.     /*----------------------------------------------------------------*/
  494.     /* Local Variables                                                */
  495.     /*----------------------------------------------------------------*/
  497.     prov_napdef_struct *tmp_p;
  499.     /*----------------------------------------------------------------*/
  500.     /* Code Body                                                      */
  501.     /*----------------------------------------------------------------*/
  502.     tmp_p = jdd_MemAlloc(sizeof(prov_napdef_struct), 1);
  504.     memcpy(&(tmp_p->accountData), accountData_p, sizeof(prov_data_account_data_struct));
  505.     tmp_p->nextNapdef_p = *napdef_data_p;
  507.     *napdef_data_p = tmp_p;
  509.     if (accountData_p != NULL)
  510.     {
  511.         jdd_MemFree(accountData_p);
  512.         accountData_p = NULL;
  513.     }
  514. }
  517. /*****************************************************************************
  518.  * FUNCTION
  519.  *  mmi_prov_oma_add_logical_proxy_info
  520.  * DESCRIPTION
  521.  *  It adds the given Logical proxy info into the  Logical proxy list
  522.  * PARAMETERS
  523.  *  logProxy_p          [IN/OUT]        
  524.  *  logProxyData_p      [IN]            
  525.  * RETURNS
  526.  *  void
  527.  *****************************************************************************/
  528. void mmi_prov_oma_add_logical_proxy_info(
  529.         prov_logical_proxy_struct **logProxy_p,
  530.         prov_log_proxy_data_struct *logProxyData_p)
  531. {
  532.     /*----------------------------------------------------------------*/
  533.     /* Local Variables                                                */
  534.     /*----------------------------------------------------------------*/
  536.     prov_logical_proxy_struct *tmp_p, *tmp1_p;
  538.     /*----------------------------------------------------------------*/
  539.     /* Code Body                                                      */
  540.     /*----------------------------------------------------------------*/
  541.     tmp1_p = *logProxy_p;
  543.     if (tmp1_p == NULL)
  544.     {
  545.    /*----First Logical proxy ------*/
  546.         tmp_p = jdd_MemAlloc(sizeof(prov_logical_proxy_struct), 1);
  547.         memcpy(&(tmp_p->logProxyData), logProxyData_p, sizeof(prov_log_proxy_data_struct));
  548.         tmp_p->nextLogProxy_p = NULL;
  549.         tmp1_p = tmp_p;
  550.     }
  551.     else
  552.     {
  553.         while ((tmp1_p->nextLogProxy_p) != NULL)
  554.         {
  555.             tmp1_p = tmp1_p->nextLogProxy_p;
  556.         }
  557.         tmp_p = jdd_MemAlloc(sizeof(prov_logical_proxy_struct), 1);
  558.         memcpy(&(tmp_p->logProxyData), logProxyData_p, sizeof(prov_log_proxy_data_struct));
  559.         tmp1_p->nextLogProxy_p = tmp_p;
  560.     }
  561.     *logProxy_p = tmp1_p;
  562. }
  565. /*****************************************************************************
  566.  * FUNCTION
  567.  *  mmi_prov_oma_add_physical_proxy_info
  568.  * DESCRIPTION
  569.  *  It adds the given physical proxy info into the  physical proxy list
  570.  * PARAMETERS
  571.  *  phyProxy_p          [IN]        INOUT
  572.  *  phyProxyData_p      [IN]        
  573.  * RETURNS
  574.  *  PROV_RETCODE(?)
  575.  *****************************************************************************/
  576. void mmi_prov_oma_add_physical_proxy_info(
  577.         prov_physical_proxy_struct **phyProxy_p,
  578.         prov_phy_proxy_data_struct *phyProxyData_p)
  579. {
  580.     /*----------------------------------------------------------------*/
  581.     /* Local Variables                                                */
  582.     /*----------------------------------------------------------------*/
  584.     prov_physical_proxy_struct *tmp_p, *tmp1_p;
  586.     /*----------------------------------------------------------------*/
  587.     /* Code Body                                                      */
  588.     /*----------------------------------------------------------------*/
  589.     tmp1_p = *phyProxy_p;
  590.     if (tmp1_p == NULL)
  591.     {
  592.    /*----First Physcial proxy ------*/
  593.         tmp_p = jdd_MemAlloc(sizeof(prov_physical_proxy_struct), 1);
  595.         memcpy(&(tmp_p->phyProxyData), phyProxyData_p, sizeof(prov_phy_proxy_data_struct));
  597.         tmp_p->nextPhyProxy_p = NULL;
  599.         tmp1_p = tmp_p;
  600.     }
  601.     else
  602.     {
  603.         while ((tmp1_p->nextPhyProxy_p) != NULL)
  604.         {
  605.             tmp1_p = tmp1_p->nextPhyProxy_p;
  606.         }
  607.         tmp_p = jdd_MemAlloc(sizeof(prov_physical_proxy_struct), 1);
  608.         memcpy(&(tmp_p->phyProxyData), phyProxyData_p, sizeof(prov_phy_proxy_data_struct));
  609.         tmp1_p->nextPhyProxy_p = tmp_p;
  610.     }
  611.     *phyProxy_p = tmp1_p;
  613.     /* tmp_p = jdd_MemAlloc(sizeof(prov_physical_proxy_struct), 1); */
  615.     /* memcpy(&(tmp_p->phyProxyData), phyProxyData_p, sizeof(prov_phy_proxy_data_struct)); */
  617.     /* tmp_p->nextPhyProxy_p = *phyProxy_p; */
  619.     /* *phyProxy_p = tmp_p; */
  621.     if (phyProxyData_p != NULL)
  622.     {
  623.         jdd_MemFree(phyProxyData_p);
  624.         phyProxyData_p = NULL;
  625.     }
  626. }
  629. /*****************************************************************************
  630.  * FUNCTION
  631.  *  mmi_prov_oma_add_pxauth_info
  632.  * DESCRIPTION
  633.  *  It updates the username & password of the logical proxy data list using the availbale values
  634.  * PARAMETERS
  635.  *  logProxy_p          [IN/OUT]        
  636.  *  logProxyData_p      [IN]            
  637.  * RETURNS
  638.  *  void
  639.  *****************************************************************************/
  640. void mmi_prov_oma_add_pxauth_info(prov_logical_proxy_struct **logProxy_p, prov_log_proxy_data_struct *logProxyData_p)
  641. {
  642.     /*----------------------------------------------------------------*/
  643.     /* Local Variables                                                */
  644.     /*----------------------------------------------------------------*/
  646.     /*----------------------------------------------------------------*/
  647.     /* Code Body                                                      */
  648.     /*----------------------------------------------------------------*/
  649.     strcpy((S8*) (*logProxy_p)->logProxyData.px_auth_id, (S8*) logProxyData_p->px_auth_id);
  650.     strcpy((S8*) (*logProxy_p)->logProxyData.px_auth_pwd, (S8*) logProxyData_p->px_auth_pwd);
  651. }
  654. /*****************************************************************************
  655.  * FUNCTION
  656.  *  mmi_prov_oma_get_application_data
  657.  * DESCRIPTION
  658.  *  THis matches the Proxy-Id & the Nap-Id of the application data with the proxy & Napdef data Lists
  659.  *  if there is no proxy-Id available conenction type fopr the Browser & MMS profile is set to HTTP
  660.  * PARAMETERS
  661.  *  appData_p       [IN]        
  662.  * RETURNS
  663.  *  PROV_OK
  664.  *****************************************************************************/
  665. PROV_RETCODE mmi_prov_oma_get_application_data(application_data *appData_p)
  666. {
  667.     /*----------------------------------------------------------------*/
  668.     /* Local Variables                                                */
  669.     /*----------------------------------------------------------------*/
  670.     PROV_RETCODE i_ret = PROV_OK;
  671.     U32 len = 0;
  673.     /*----------------------------------------------------------------*/
  674.     /* Code Body                                                      */
  675.     /*----------------------------------------------------------------*/
  676.     len = strlen((S8*) appData_p->application_name);
  677.     if (len)
  678.     {
  679.         if (len >= PROV_PROFILE_PROFILE_NAME_LEN)
  680.         {
  681.             len = PROV_PROFILE_PROFILE_NAME_LEN - 1;
  682.         }
  683.         if (g_prov_profile_name_p == NULL)
  684.         {
  685.             g_prov_profile_name_p = (U8*) jdd_MemAlloc(PROV_PROFILE_PROFILE_NAME_LEN + 1, 1);
  686.             memcpy((S8*) g_prov_profile_name_p, (S8*) appData_p->application_name, len);
  687.         }
  688.     }
  690.     if (strlen((S8*) appData_p->proxy_id))
  691.     {
  692.         i_ret = mmi_prov_oma_search_and_fill_proxy_data(appData_p);
  693.     }
  694.     else if (strlen((S8*) appData_p->nap_id))
  695.     {
  696.         /* NOTE : Since there is no TO-PROXYID reference ....so the HTTP direct will be teh connection type */
  697.         if (g_prov_appl_flag & PROV_BROWSER_APPLICATION)
  698.         {
  699.             if (g_ph_wap_profile_p == NULL)
  700.             {
  701.                 g_ph_wap_profile_p =
  702.                     (nvram_wap_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_WAP_PROFILE_CONTENT_SIZE, 1);
  703.             }
  704.             g_ph_wap_profile_p->proxy_port = PROV_DEFAULT_HTTP_PORT;    /* default HTTP port */
  705.             g_ph_wap_profile_p->conn_type = PH_CONN_TYPE_HTTP;
  706.         }
  707.         else if (g_prov_appl_flag & PROV_MMS_APPLICATION)
  708.         {
  709.             if (g_ph_mms_profile_p == NULL)
  710.             {
  711.                 g_ph_mms_profile_p =
  712.                     (nvram_mms_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_MMS_PROFILE_CONTENT_SIZE, 1);
  713.             }
  714.             g_ph_mms_profile_p->proxy_port = PROV_DEFAULT_HTTP_PORT;    /* default HTTP port */
  715.             g_ph_mms_profile_p->conn_type = PH_CONN_TYPE_HTTP;
  716.         }
  718.         i_ret = mmi_prov_oma_compare_appl_napdef_napid(appData_p);
  719.     }
  720.     else
  721.     {
  722.         return PROV_ERR;
  723.     }
  724.     return i_ret;
  725. }
  728. /*****************************************************************************
  729.  * FUNCTION
  730.  *  mmi_prov_oma_search_and_fill_proxy_data
  731.  * DESCRIPTION
  732.  *  It searches and matches the proxy-Id available with the application data & the physical proxy data list
  733.  * PARAMETERS
  734.  *  appData_p       [IN]        
  735.  * RETURNS
  736.  *  PROV_RETCODE
  737.  *****************************************************************************/
  738. PROV_RETCODE mmi_prov_oma_search_and_fill_proxy_data(application_data *appData_p)
  739. {
  740.     /*----------------------------------------------------------------*/
  741.     /* Local Variables                                                */
  742.     /*----------------------------------------------------------------*/
  743.     PROV_RETCODE i_ret = PROV_OK;
  744.     U32 count = 0x00;
  745.     prov_logical_proxy_struct *tmp_logical_p = g_prov_proxy_data_p;
  747.     /*----------------------------------------------------------------*/
  748.     /* Code Body                                                      */
  749.     /*----------------------------------------------------------------*/
  750.     count = mmi_prov_oma_get_logical_proxy_count(tmp_logical_p);
  752.     if (count == 0x00)
  753.     {
  754.         return PROV_ERR;
  755.     }
  756.     else if (count == 0x01)
  757.     {
  758.         i_ret = mmi_prov_oma_search_physical_proxy(&tmp_logical_p->logProxyData);
  759.         return i_ret;
  760.     }
  761.     else
  762.     {
  763.         do
  764.         {
  765.             if (strcmp((S8*) appData_p->proxy_id, (S8*) tmp_logical_p->logProxyData.proxy_id) == 0)
  766.             {
  768.                 i_ret = mmi_prov_oma_search_physical_proxy(&tmp_logical_p->logProxyData);
  769.                 return i_ret;
  770.             }
  771.             tmp_logical_p = tmp_logical_p->nextLogProxy_p;
  772.         } while (tmp_logical_p != NULL);
  773.     }
  774.     return PROV_ERR;
  775. }
  778. /*****************************************************************************
  779.  * FUNCTION
  780.  *  mmi_prov_oma_search_physical_proxy
  781.  * DESCRIPTION
  782.  *  It gets the count of the physical proxy,and if there are more than one
  783.  *  then matches the NAPID of the first physical proxy with the NAPID available with the Napdef data
  784.  *  once the match is made it updates the global instances WAP & MMS profiles
  785.  * PARAMETERS
  786.  *  logProxy_p      [IN]        
  787.  * RETURNS
  788.  *  PROV_OK
  789.  *****************************************************************************/
  790. PROV_RETCODE mmi_prov_oma_search_physical_proxy(prov_log_proxy_data_struct *logProxy_p)
  791. {
  792.     /*----------------------------------------------------------------*/
  793.     /* Local Variables                                                */
  794.     /*----------------------------------------------------------------*/
  795.     PROV_RETCODE i_ret = PROV_OK;
  796.     U32 count;
  797.     prov_physical_proxy_struct *tmp_physical_p = logProxy_p->physicalProxy;
  799.     /*----------------------------------------------------------------*/
  800.     /* Code Body                                                      */
  801.     /*----------------------------------------------------------------*/
  802.     mmi_prov_oma_get_logical_proxy_data(logProxy_p);
  804.     count = mmi_prov_oma_get_physical_proxy_count(tmp_physical_p);
  806.     if (count == 0x00)
  807.     {
  808.         return PROV_ERR;
  809.     }
  810.     else
  811.     {
  812.         i_ret = mmi_prov_oma_compare_phproxy_napdef_napid(&tmp_physical_p->phyProxyData);
  813.         if (i_ret == PROV_ERR)
  814.         {
  815.             if (g_prov_appl_flag & PROV_BROWSER_APPLICATION)
  816.             {
  817.                 i_ret = mmi_prov_oma_compare_appl_napdef_napid(g_prov_app_brw_p);
  818.             }
  819.             else if (g_prov_appl_flag & PROV_MMS_APPLICATION)
  820.             {
  821.                 i_ret = mmi_prov_oma_compare_appl_napdef_napid(g_prov_app_mms_p);
  822.             }
  823.             if (i_ret == PROV_ERR)
  824.             {
  825.                 return i_ret;
  826.             }
  827.         }
  828.         i_ret = mmi_prov_oma_get_physical_proxy_data(&tmp_physical_p->phyProxyData);
  829.         return i_ret;
  830.     }
  831.     //    else if (count == 0x01)
  832.     //    {
  833.     //        i_ret = mmi_prov_oma_compare_phproxy_napdef_napid(&tmp_physical_p->phyProxyData);
  834.     //                if(i_ret==PROV_ERR)
  835.     //                {
  836.     //                       return i_ret;
  837.     //                } 
  838.     //        i_ret=mmi_prov_oma_get_physical_proxy_data(&tmp_physical_p->phyProxyData);
  839.     //        return i_ret;
  840.     //    }
  841.     //    else
  842.     //    {
  843.     //        do
  844.     //        {
  845.     //            if (count == 0x01)
  846.     //            {
  847.     //  /* select the first Physical proxy in the logical proxy */
  848.     //                i_ret = mmi_prov_oma_compare_phproxy_napdef_napid(&tmp_physical_p->phyProxyData);
  849.     //                              if(i_ret==PROV_ERR)
  850.     //                              {
  851.     //                                      return i_ret;
  852.     //                              } 
  853.     //                i_ret=mmi_prov_oma_get_physical_proxy_data(&tmp_physical_p->phyProxyData);
  854.     //                return i_ret;
  855.     //            }
  856.     //            tmp_physical_p = tmp_physical_p->nextPhyProxy_p;
  857.     //            --count;
  858.     //        } while (tmp_physical_p != NULL);
  859.     //    }
  860.     //    return PROV_ERR;
  861. }
  864. /*****************************************************************************
  865.  * FUNCTION
  866.  *  mmi_prov_oma_get_logical_proxy_data
  867.  * DESCRIPTION
  868.  *  This Fills up the profile struct info from the logical proxy data ,
  869.  *  like profile name ,username ,password
  870.  * PARAMETERS
  871.  *  logProxy_p      [IN]        
  872.  * RETURNS
  873.  *  PROV_RETCODE(?)
  874.  *****************************************************************************/
  875. void mmi_prov_oma_get_logical_proxy_data(prov_log_proxy_data_struct *logProxy_p)
  876. {
  877.     /*----------------------------------------------------------------*/
  878.     /* Local Variables                                                */
  879.     /*----------------------------------------------------------------*/
  880.     U32 len = 0;
  882.     /*----------------------------------------------------------------*/
  883.     /* Code Body                                                      */
  884.     /*----------------------------------------------------------------*/
  885.     if (g_prov_profile_name_p == NULL)
  886.     {
  887.         g_prov_profile_name_p = (U8*) jdd_MemAlloc(PROV_PROFILE_PROFILE_NAME_LEN + 1, 1);
  888.         strcpy((S8*) g_prov_profile_name_p, (S8*) logProxy_p->proxy_name);
  889.     }
  891.     if (g_prov_appl_flag & PROV_BROWSER_APPLICATION)
  892.     {
  894.         if (g_ph_wap_profile_p == NULL)
  895.         {
  896.             g_ph_wap_profile_p =
  897.                 (nvram_wap_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_WAP_PROFILE_CONTENT_SIZE, 1);
  898.         }
  900.         strcpy((S8*) g_ph_wap_profile_p->username, (S8*) logProxy_p->px_auth_id);
  901.         strcpy((S8*) g_ph_wap_profile_p->password, (S8*) logProxy_p->px_auth_pwd);
  903. //MAUI_00355388 Start
  904. len = strlen((S8*) g_ph_wap_profile_p->homepage_url);
  905. if ( len == 0 )   // Homepage url is not updated thru application tag. so update with logProxy data
  906. {
  907. mmi_prov_oma_update_wap_profile_homepage_url(logProxy_p->homepage_url);
  909. }
  910. // MAUI_00355388 End
  911.     }
  912.     else if (g_prov_appl_flag & PROV_MMS_APPLICATION)
  913.     {
  914.         if (g_ph_mms_profile_p == NULL)
  915.         {
  916.             g_ph_mms_profile_p =
  917.                 (nvram_mms_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_MMS_PROFILE_CONTENT_SIZE, 1);
  918.         }
  919.         strcpy((S8*) g_ph_mms_profile_p->username, (S8*) logProxy_p->px_auth_id);
  920.         strcpy((S8*) g_ph_mms_profile_p->password, (S8*) logProxy_p->px_auth_pwd);
  922. // MAUI_00355388 Start
  923. len = strlen((S8*) g_ph_mms_profile_p->mmsc_url);
  924. if (len == 0) // Mmsc url is not updated thru application tag. so update with logProxy data
  925. {
  926. mmi_prov_oma_update_mms_profile_mmsc_url(logProxy_p->homepage_url);
  928. }
  929. // MAUI_00355388 End
  930.     }
  931. }
  934. /*****************************************************************************
  935.  * FUNCTION
  936.  *  mmi_prov_oma_get_physical_proxy_data
  937.  * DESCRIPTION
  938.  *  This fills up the profile struct info from the physical proxy data ,
  939.  *  like connection type ,port ,IP
  940.  * PARAMETERS
  941.  *  phy_Proxy_p     [IN]        
  942.  * RETURNS
  943.  *  PROV_RETCODE(?)
  944.  *****************************************************************************/
  945. PROV_RETCODE mmi_prov_oma_get_physical_proxy_data(prov_phy_proxy_data_struct *phy_Proxy_p)
  946. {
  947.     /*----------------------------------------------------------------*/
  948.     /* Local Variables                                                */
  949.     /*----------------------------------------------------------------*/
  950.     PROV_RETCODE i_ret = PROV_OK;
  951.     PROV_RETCODE ret_code = PROV_OK;
  953.     /*----------------------------------------------------------------*/
  954.     /* Code Body                                                      */
  955.     /*----------------------------------------------------------------*/
  956.     if (phy_Proxy_p->port >= PH_USHORT_MAX)
  957.     {
  958.         phy_Proxy_p->port = 0x00;
  959.         phy_Proxy_p->port = 0x00;
  960.     }
  961.     else if ((phy_Proxy_p->port == 9200) || (phy_Proxy_p->port == 9202))
  962.     {
  963.         return PROV_ERR;
  964.     }
  966.     if (g_prov_appl_flag & PROV_BROWSER_APPLICATION)
  967.     {
  968.         if (g_ph_wap_profile_p == NULL)
  969.         {
  970.             g_ph_wap_profile_p =
  971.                 (nvram_wap_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_WAP_PROFILE_CONTENT_SIZE, 1);
  972.         }
  974.         g_ph_wap_profile_p->proxy_port = phy_Proxy_p->port;
  975.         g_ph_wap_profile_p->conn_type = phy_Proxy_p->connType;
  977.         if (g_ph_wap_profile_p->proxy_port == 9201)
  978.         {
  979.             g_ph_wap_profile_p->conn_type = PH_CONN_TYPE_CONNECTION_OREINTED;
  981.         }
  982.         else if (g_ph_wap_profile_p->proxy_port == 9203)
  983.         {
  984.             g_ph_wap_profile_p->conn_type = PH_CONN_TYPE_CONNECTION_OREINTED_SECURE;
  986.         }
  987.         else
  988.         {
  989.             /* default case */
  990.             g_ph_wap_profile_p->conn_type = PH_CONN_TYPE_HTTP;
  991.         }
  993.         ret_code = mmi_prov_convert_ip_string_to_array((S8*) phy_Proxy_p->pxAddr, (U8*) g_ph_wap_profile_p->proxy_ip);
  994.         if (ret_code == PROV_ERR)
  995.         {
  996.             memset(g_ph_wap_profile_p->proxy_ip, 0, MAX_PART_IP_ADDRESS);
  997.         }
  999.     }
  1000.     else if (g_prov_appl_flag & PROV_MMS_APPLICATION)
  1001.     {
  1002.         if (g_ph_mms_profile_p == NULL)
  1003.         {
  1004.             g_ph_mms_profile_p =
  1005.                 (nvram_mms_profile_content_struct*) jdd_MemAlloc(NVRAM_EF_MMS_PROFILE_CONTENT_SIZE, 1);
  1006.         }
  1008.         g_ph_mms_profile_p->proxy_port = phy_Proxy_p->port;
  1009.         g_ph_mms_profile_p->conn_type = phy_Proxy_p->connType;
  1011.         if (g_ph_mms_profile_p->proxy_port == 9201)
  1012.         {
  1013.             g_ph_mms_profile_p->conn_type = PH_CONN_TYPE_CONNECTION_OREINTED;
  1015.         }
  1016.         else if (g_ph_mms_profile_p->proxy_port == 9203)
  1017.         {
  1018.             g_ph_mms_profile_p->conn_type = PH_CONN_TYPE_CONNECTION_OREINTED_SECURE;
  1020.         }
  1021.         else
  1022.         {
  1023.             /* default case */
  1024.             g_ph_mms_profile_p->conn_type = PH_CONN_TYPE_HTTP;
  1025.         }
  1027.         ret_code = mmi_prov_convert_ip_string_to_array((S8*) phy_Proxy_p->pxAddr, (U8*) g_ph_mms_profile_p->proxy_ip);
  1028.         if (ret_code == PROV_ERR)
  1029.         {
  1030.             memset(g_ph_mms_profile_p->proxy_ip, 0, MAX_PART_IP_ADDRESS);
  1031.         }
  1033.     }
  1034.     return i_ret;
  1035. }
  1038. /*****************************************************************************
  1039.  * FUNCTION
  1040.  *  mmi_prov_oma_compare_phproxy_napdef_napid
  1041.  * DESCRIPTION
  1042.  *  THis compares the physical proxy Nap-Id with the Nap-ID's available with the NApdef data list
  1043.  * PARAMETERS
  1044.  *  phyProxyData_p      [IN]        
  1045.  * RETURNS
  1046.  *  PROV_RETCODE
  1047.  *****************************************************************************/
  1048. PROV_RETCODE mmi_prov_oma_compare_phproxy_napdef_napid(prov_phy_proxy_data_struct *phyProxyData_p)
  1049. {
  1050.     /*----------------------------------------------------------------*/
  1051.     /* Local Variables                                                */
  1052.     /*----------------------------------------------------------------*/
  1053.     prov_napdef_struct *tmp_data_account_p = g_prov_napdef_data_p;
  1054.     PROV_RETCODE i_ret = PROV_OK;
  1056.     /*----------------------------------------------------------------*/
  1057.     /* Code Body                                                      */
  1058.     /*----------------------------------------------------------------*/
  1059.     if (g_prov_dataAccountData_p == NULL)
  1060.     {
  1061.         g_prov_dataAccountData_p = jdd_MemAlloc(sizeof(prov_data_account_data_struct), 1);
  1062.     }
  1064.     do
  1065.     {
  1066.         if (strcmp((S8*) phyProxyData_p->toNapID, (S8*) tmp_data_account_p->accountData.napid) == 0)
  1067.         {
  1068.             //NOTE : what to do if no valid matching NAPDEF is there ?              
  1069.             //if not availbale this way get it from the Application data
  1070.             memcpy(g_prov_dataAccountData_p, &(tmp_data_account_p->accountData), sizeof(prov_data_account_data_struct));
  1071.             g_prov_bearer = g_prov_dataAccountData_p->bearer;
  1072.             return i_ret;
  1074.         }
  1075.         tmp_data_account_p = tmp_data_account_p->nextNapdef_p;
  1076.     } while (tmp_data_account_p != NULL);
  1077.     return PROV_ERR;
  1078. }
  1081. /*****************************************************************************
  1082.  * FUNCTION
  1083.  *  mmi_prov_oma_compare_appl_napdef_napid
  1084.  * DESCRIPTION
  1085.  *  It compares the Nap-ID available with the application data & that in the Napdef data list
  1086.  * PARAMETERS
  1087.  *  appData_p       [IN]        
  1088.  * RETURNS
  1089.  *  PROV_RETCODE
  1090.  *****************************************************************************/
  1091. PROV_RETCODE mmi_prov_oma_compare_appl_napdef_napid(application_data *appData_p)
  1092. {
  1093.     /*----------------------------------------------------------------*/
  1094.     /* Local Variables                                                */
  1095.     /*----------------------------------------------------------------*/
  1097.     prov_napdef_struct *tmp_data_account_p = g_prov_napdef_data_p;
  1098.     PROV_RETCODE i_ret = PROV_OK;
  1100.     /*----------------------------------------------------------------*/
  1101.     /* Code Body                                                      */
  1102.     /*----------------------------------------------------------------*/
  1103.     if (g_prov_dataAccountData_p == NULL)
  1104.     {
  1105.         g_prov_dataAccountData_p = jdd_MemAlloc(sizeof(prov_data_account_data_struct), 1);
  1106.     }
  1108.     do
  1109.     {
  1110.         if (strcmp((S8*) appData_p->nap_id, (S8*) tmp_data_account_p->accountData.napid) == 0)
  1111.         {
  1112.             //NOTE : what to do if no valid matching NAPDEF is there ?              
  1113.             //if not availbale this way get it from the Application data
  1114.             memcpy(g_prov_dataAccountData_p, &(tmp_data_account_p->accountData), sizeof(prov_data_account_data_struct));
  1115.             g_prov_bearer = g_prov_dataAccountData_p->bearer;
  1116.             return i_ret;
  1118.         }
  1119.         tmp_data_account_p = tmp_data_account_p->nextNapdef_p;
  1120.     } while (tmp_data_account_p != NULL);
  1121.     return PROV_ERR;
  1122. }
  1125. /*****************************************************************************
  1126.  * FUNCTION
  1127.  *  mmi_prov_oma_fill_gprs_data_account_info
  1128.  * DESCRIPTION
  1129.  *  This fills the data account info available into the set gprs req. struct
  1130.  * PARAMETERS
  1131.  *  dataAccountData_p       [IN]            
  1132.  *  set_gprs_req_p          [IN/OUT]        
  1133.  * RETURNS
  1134.  *  void
  1135.  *****************************************************************************/
  1136. void mmi_prov_oma_fill_gprs_data_account_info(
  1137.         prov_data_account_data_struct *dataAccountData_p,
  1138.         mmi_ps_set_gprs_data_account_req_struct **set_gprs_req_p)
  1139. {
  1140.     /*----------------------------------------------------------------*/
  1141.     /* Local Variables                                                */
  1142.     /*----------------------------------------------------------------*/
  1144.     U32 len;
  1146.     /*----------------------------------------------------------------*/
  1147.     /* Code Body                                                      */
  1148.     /*----------------------------------------------------------------*/
  1149.     len = strlen((S8*) dataAccountData_p->name);
  1150.     if (len >= PROV_MAX_GPRS_DATAACCOUNT_NAME)
  1151.     {
  1152.         len = PROV_MAX_GPRS_DATAACCOUNT_NAME - 1;
  1153.     }
  1154.     (*set_gprs_req_p)->gprs_account.name_dcs = PHB_ASCII;
  1155.     (*set_gprs_req_p)->gprs_account.name_length = len;
  1157.     memcpy((S8*) (*set_gprs_req_p)->gprs_account.name, (S8*) dataAccountData_p->name, len);
  1158.     (*set_gprs_req_p)->gprs_account.name[len] = '';
  1160.     len = strlen((S8*) dataAccountData_p->dataAccountType.gprsAccount.apn);
  1161. if (len >= PROV_MAX_GPRS_MMI_APN_LEN)
  1162.     {
  1163.         len = PROV_MAX_GPRS_MMI_APN_LEN - 1;    /* modified by tk */
  1164.     }
  1165. (*set_gprs_req_p)->gprs_account.apn_length = len;
  1166.     memcpy((S8*) (*set_gprs_req_p)->gprs_account.apn, dataAccountData_p->dataAccountType.gprsAccount.apn, len);
  1167.     (*set_gprs_req_p)->gprs_account.apn[len] = '';
  1169.     (*set_gprs_req_p)->gprs_account.authentication_type = dataAccountData_p->authType;
  1171.     len = strlen((S8*) dataAccountData_p->userName);
  1172.     if (len >= PROV_MAX_GPRS_USERNAME)
  1173.     {
  1174.         len = PROV_MAX_GPRS_USERNAME - 1;
  1175.     }
  1176.     memcpy((*set_gprs_req_p)->gprs_account.user_name, dataAccountData_p->userName, len);
  1177.     (*set_gprs_req_p)->gprs_account.user_name[len] = '';
  1179.     len = strlen((S8*) dataAccountData_p->password);
  1180.     if (len >= PROV_MAX_GPRS_USERPASSWD)
  1181.     {
  1182.         len = PROV_MAX_GPRS_USERPASSWD - 1;
  1183.     }
  1184.     memcpy((*set_gprs_req_p)->gprs_account.password, dataAccountData_p->password, len);
  1185.     (*set_gprs_req_p)->gprs_account.password[len] = '';
  1186. }
  1189. /*****************************************************************************
  1190.  * FUNCTION
  1191.  *  mmi_prov_oma_fill_csd_data_account_info
  1192.  * DESCRIPTION
  1193.  *  It fills the data account info into the set csd profile req. structure
  1194.  * PARAMETERS
  1195.  *  dataAccountData_p       [IN]            
  1196.  *  set_csd_req_p           [IN/OUT]        
  1197.  * RETURNS
  1198.  *  void
  1199.  *****************************************************************************/
  1200. void mmi_prov_oma_fill_csd_data_account_info(
  1201.         prov_data_account_data_struct *dataAccountData_p,
  1202.         mmi_cc_set_csd_profile_req_struct **set_csd_req_p)
  1203. {
  1204.     /*----------------------------------------------------------------*/
  1205.     /* Local Variables                                                */
  1206.     /*----------------------------------------------------------------*/
  1208.     U32 len;
  1210.     /*----------------------------------------------------------------*/
  1211.     /* Code Body                                                      */
  1212.     /*----------------------------------------------------------------*/
  1213.     len = strlen((S8*) dataAccountData_p->name);
  1214.     if (len >= PROV_MAX_DATA_ACCOUNT_NAME_LEN)
  1215.     {
  1216.         len = PROV_MAX_DATA_ACCOUNT_NAME_LEN - 1;
  1217.     }
  1219.     memcpy((S8*) (*set_csd_req_p)->name.name, (S8*) dataAccountData_p->name, len);
  1220.     (*set_csd_req_p)->name.name[len] = '';
  1222.     (*set_csd_req_p)->name.name_dcs = PHB_ASCII;
  1223.     (*set_csd_req_p)->name.name_length = len;
  1225.     (*set_csd_req_p)->dest.type = dataAccountData_p->dataAccountType.csdAccount.csdDialNumType;
  1227.     len = strlen((S8*) dataAccountData_p->dataAccountType.csdAccount.csdDialString);
  1228.     if (len >= PROV_MAX_DIAL_NUM_LEN)
  1229.     {
  1230.         len = PROV_MAX_DIAL_NUM_LEN - 1;
  1231.     }
  1232.     memcpy(
  1233.         (S8*) ((*set_csd_req_p)->dest.number),
  1234.         (S8*) dataAccountData_p->dataAccountType.csdAccount.csdDialString,
  1235.         len);
  1236.     (*set_csd_req_p)->dest.number[len] = '';
  1238.     (*set_csd_req_p)->auth_type = dataAccountData_p->authType;
  1240.     len = strlen((S8*) dataAccountData_p->userName);
  1241.     if (len >= PROV_MAX_USER_LEN)
  1242.     {
  1243.         len = PROV_MAX_USER_LEN - 1;
  1244.     }
  1245.     memcpy((*set_csd_req_p)->user_id, dataAccountData_p->userName, len);
  1246.     (*set_csd_req_p)->user_id[len] = '';
  1248.     len = strlen((S8*) dataAccountData_p->password);
  1249.     if (len >= PROV_MAX_PASSWD_LEN)
  1250.     {
  1251.         len = PROV_MAX_PASSWD_LEN - 1;
  1252.     }
  1253.     memcpy((*set_csd_req_p)->passwd, dataAccountData_p->password, len);
  1254.     (*set_csd_req_p)->passwd[len] = '';
  1256.     memcpy((*set_csd_req_p)->dns, dataAccountData_p->dataAccountType.csdAccount.dns_ip, 4);
  1258.     (*set_csd_req_p)->type = dataAccountData_p->dataAccountType.csdAccount.callType;
  1259.     (*set_csd_req_p)->rate = dataAccountData_p->dataAccountType.csdAccount.linkSpeed;
  1260. }
  1263. /*****************************************************************************
  1264.  * FUNCTION
  1265.  *  mmi_prov_oma_free_napdef_info
  1266.  * DESCRIPTION
  1267.  *  Frees the data with Napdef data list
  1268.  * PARAMETERS
  1269.  *  void
  1270.  * RETURNS
  1271.  *  void
  1272.  *****************************************************************************/
  1273. void mmi_prov_oma_free_napdef_info(void)
  1274. {
  1275.     /*----------------------------------------------------------------*/
  1276.     /* Local Variables                                                */
  1277.     /*----------------------------------------------------------------*/
  1279.     /*----------------------------------------------------------------*/
  1280.     /* Code Body                                                      */
  1281.     /*----------------------------------------------------------------*/
  1282.     while (g_prov_napdef_data_p != NULL)
  1283.     {
  1284.         jdd_MemFree(g_prov_napdef_data_p);
  1285.         g_prov_napdef_data_p = g_prov_napdef_data_p->nextNapdef_p;
  1286.     }
  1287. }
  1290. /*****************************************************************************
  1291.  * FUNCTION
  1292.  *  mmi_prov_oma_free_proxy_info
  1293.  * DESCRIPTION
  1294.  *  It frees memory with proxy data list(both logical & Physical)
  1295.  * PARAMETERS
  1296.  *  void
  1297.  * RETURNS
  1298.  *  void
  1299.  *****************************************************************************/
  1300. void mmi_prov_oma_free_proxy_info(void)
  1301. {
  1302.     /*----------------------------------------------------------------*/
  1303.     /* Local Variables                                                */
  1304.     /*----------------------------------------------------------------*/
  1306.     /*----------------------------------------------------------------*/
  1307.     /* Code Body                                                      */
  1308.     /*----------------------------------------------------------------*/
  1309.     while (g_prov_proxy_data_p != NULL)
  1310.     {
  1312.         while (g_prov_proxy_data_p->logProxyData.physicalProxy != NULL)
  1313.         {
  1315.             jdd_MemFree(g_prov_proxy_data_p->logProxyData.physicalProxy);
  1316.             g_prov_proxy_data_p->logProxyData.physicalProxy =
  1317.                 g_prov_proxy_data_p->logProxyData.physicalProxy->nextPhyProxy_p;
  1318.         }
  1319.         jdd_MemFree(g_prov_proxy_data_p);
  1320.         g_prov_proxy_data_p = g_prov_proxy_data_p->nextLogProxy_p;
  1322.     }
  1323. }
  1326. /*****************************************************************************
  1327.  * FUNCTION
  1328.  *  mmi_prov_oma_get_physical_proxy_count
  1329.  * DESCRIPTION
  1330.  *  This function counts the no of physical proxies with a particular logical proxy
  1331.  * PARAMETERS
  1332.  *  phyProxy_p      [IN]        
  1333.  * RETURNS
  1334.  *  PROV_RETCODE
  1335.  *****************************************************************************/
  1336. U8 mmi_prov_oma_get_physical_proxy_count(prov_physical_proxy_struct *phyProxy_p)
  1337. {
  1338.     /*----------------------------------------------------------------*/
  1339.     /* Local Variables                                                */
  1340.     /*----------------------------------------------------------------*/
  1341.     U32 count = 0x00;
  1343.     /*----------------------------------------------------------------*/
  1344.     /* Code Body                                                      */
  1345.     /*----------------------------------------------------------------*/
  1346.     while (phyProxy_p != NULL)
  1347.     {
  1348.         ++count;
  1349.         phyProxy_p = phyProxy_p->nextPhyProxy_p;
  1350.     }
  1351.     return count;
  1352. }
  1355. /*****************************************************************************
  1356.  * FUNCTION
  1357.  *  mmi_prov_oma_get_logical_proxy_count
  1358.  * DESCRIPTION
  1359.  *  This function counts the no. of logical proxies
  1360.  * PARAMETERS
  1361.  *  logProxy_p      [IN]        
  1362.  * RETURNS
  1363.  *  PROV_RETCODE
  1364.  *****************************************************************************/
  1365. U8 mmi_prov_oma_get_logical_proxy_count(prov_logical_proxy_struct *logProxy_p)
  1366. {
  1367.     /*----------------------------------------------------------------*/
  1368.     /* Local Variables                                                */
  1369.     /*----------------------------------------------------------------*/
  1370.     U32 count = 0x00;
  1372.     /*----------------------------------------------------------------*/
  1373.     /* Code Body                                                      */
  1374.     /*----------------------------------------------------------------*/
  1375.     while (logProxy_p != NULL)
  1376.     {
  1377.         ++count;
  1378.         logProxy_p = logProxy_p->nextLogProxy_p;
  1379.     }
  1380.     return count;
  1381. }
  1384. /*****************************************************************************
  1385.  * FUNCTION
  1386.  *  mmi_prov_oma_check_if_redundant_logical_proxy
  1387.  * DESCRIPTION
  1388.  *  This function checks if the logical proxy is an redundant one,ie already defined
  1389.  * PARAMETERS
  1390.  *  logProxy_p          [IN]        
  1391.  *  logProxyData_p      [IN]        
  1392.  * RETURNS
  1393.  *  PROV_RETCODE
  1394.  *****************************************************************************/
  1395. U8 mmi_prov_oma_check_if_redundant_logical_proxy(
  1396.     prov_logical_proxy_struct *logProxy_p,
  1397.     prov_log_proxy_data_struct *logProxyData_p)
  1398. {
  1399.     /*----------------------------------------------------------------*/
  1400.     /* Local Variables                                                */
  1401.     /*----------------------------------------------------------------*/
  1403.     /*----------------------------------------------------------------*/
  1404.     /* Code Body                                                      */
  1405.     /*----------------------------------------------------------------*/
  1406.     while (logProxy_p != NULL)
  1407.     {
  1409.         if (strcmp((S8*) logProxyData_p->proxy_id, (S8*) logProxy_p->logProxyData.proxy_id) == 0)
  1410.         {
  1411.             return 0x01;
  1412.         }
  1414.         logProxy_p = logProxy_p->nextLogProxy_p;
  1415.     }
  1416.     return 0;
  1418. }
  1421. /*****************************************************************************
  1422.  * FUNCTION
  1423.  *  mmi_prov_oma_check_if_redundant_physical_proxy
  1424.  * DESCRIPTION
  1425.  *  This function checks if the physical proxy is an redundant one,ie already defined
  1426.  * PARAMETERS
  1427.  *  phyProxy_p          [IN]        
  1428.  *  phyProxyData_p      [IN]        
  1429.  * RETURNS
  1430.  *  TRUE if its redundant
  1431.  *****************************************************************************/
  1432. U8 mmi_prov_oma_check_if_redundant_physical_proxy(
  1433.     prov_physical_proxy_struct *phyProxy_p,
  1434.     prov_phy_proxy_data_struct *phyProxyData_p)
  1435. {
  1436.     /*----------------------------------------------------------------*/
  1437.     /* Local Variables                                                */
  1438.     /*----------------------------------------------------------------*/
  1440.     /*----------------------------------------------------------------*/
  1441.     /* Code Body                                                      */
  1442.     /*----------------------------------------------------------------*/
  1443.     while (phyProxy_p != NULL)
  1444.     {
  1446.         if (strcmp((S8*) phyProxyData_p->physicalProxyID, (S8*) phyProxy_p->phyProxyData.physicalProxyID) == 0)
  1447.         {
  1448.             return 0x01;
  1449.         }
  1451.         phyProxy_p = phyProxy_p->nextPhyProxy_p;
  1452.     }
  1453.     return 0;
  1455. }
  1458. /*****************************************************************************
  1459.  * FUNCTION
  1460.  *  mmi_prov_oma_check_if_redundant_napdef
  1461.  * DESCRIPTION
  1462.  *  This function checks if the NAP defination is an redundant one,ie already defined
  1463.  * PARAMETERS
  1464.  *  napdef_data_p       [IN]        
  1465.  *  accountData_p       [IN]        
  1466.  * RETURNS
  1467.  *  PROV_RETCODE
  1468.  *****************************************************************************/
  1469. U8 mmi_prov_oma_check_if_redundant_napdef(
  1470.     prov_napdef_struct *napdef_data_p,
  1471.     prov_data_account_data_struct *accountData_p)
  1472. {
  1473.     /*----------------------------------------------------------------*/
  1474.     /* Local Variables                                                */
  1475.     /*----------------------------------------------------------------*/
  1477.     /*----------------------------------------------------------------*/
  1478.     /* Code Body                                                      */
  1479.     /*----------------------------------------------------------------*/
  1480.     while (napdef_data_p != NULL)
  1481.     {
  1483.         if (strcmp((S8*) napdef_data_p->accountData.napid, (S8*) accountData_p->napid) == 0)
  1484.         {
  1485.             return 0x01;
  1486.         }
  1487.         napdef_data_p = napdef_data_p->nextNapdef_p;
  1488.     }
  1490.     if ((accountData_p->bearer == PROV_GPRS_BEARER) || (accountData_p->bearer == PROV_CSD_BEARER))
  1491.     {
  1492.         return 0;
  1493.     }
  1494.     else
  1495.     {
  1496.         /* Do not store the NAPDEF without the supported bearer */
  1497.         return 1;
  1498.     }
  1499. }
  1502. /*****************************************************************************
  1503.  * FUNCTION
  1504.  *  mmi_prov_oma_entry_enter_pin
  1505.  * DESCRIPTION
  1506.  *  Entry fn to get PIN from user.
  1507.  * PARAMETERS
  1508.  *  void
  1509.  * RETURNS
  1510.  *  void
  1511.  *****************************************************************************/
  1512. void mmi_prov_oma_entry_enter_pin(void)
  1513. {
  1514.     /*----------------------------------------------------------------*/
  1515.     /* Local Variables                                                */
  1516.     /*----------------------------------------------------------------*/
  1517.     U8 *gui_buffer_p;   /* Buffer holding history data */
  1518.     U8 *inputBuffer;
  1520.     /*----------------------------------------------------------------*/
  1521.     /* Code Body                                                      */
  1522.     /*----------------------------------------------------------------*/
  1523.     EntryNewScreen(SCR_ID_PROV_OMA_ENTER_PIN, mmi_prov_oma_exit_enter_pin, NULL, NULL);
  1525.     gui_buffer_p = GetCurrGuiBuffer(SCR_ID_PROV_OMA_ENTER_PIN);
  1526.     inputBuffer = GetCurrInputBuffer(SCR_ID_PROV_OMA_ENTER_PIN);
  1528.     if (inputBuffer == NULL)
  1529.     {
  1530.         memset(g_prov_password, 0, (PROV_OMA_MAX_PASSWD_LEN + 1) * ENCODING_LENGTH);
  1531.     }
  1532.     else
  1533.     {
  1534.         pfnUnicodeStrcpy((S8*) g_prov_password, (S8*) inputBuffer);
  1535.     }
  1537.     RegisterInputBoxValidationFunction(mmi_prov_oma_pin_length_validation);
  1538.     ShowCategory111Screen(
  1539.         STR_GLOBAL_OK,
  1540.         IMG_GLOBAL_OK,
  1541.         STR_GLOBAL_BACK,
  1542.         IMG_GLOBAL_BACK,
  1543.         STR_ID_PROV_ENTER_PIN_CAPTION,
  1544.         INPUT_TYPE_NUMERIC_PASSWORD,
  1545.         g_prov_password,
  1546.         (PROV_OMA_MAX_PASSWD_LEN + 1),
  1547.         NULL,
  1548.         gui_buffer_p);
  1550.     SetCategory111RightSoftkeyFunction(GoBackHistory, KEY_EVENT_UP);
  1551.     SetLeftSoftkeyFunction(mmi_prov_oma_validate_entered_pin, KEY_EVENT_UP);
  1552.     SetKeyHandler(mmi_prov_oma_validate_entered_pin, KEY_POUND, KEY_EVENT_UP);
  1554. }
  1557. /*****************************************************************************
  1558.  * FUNCTION
  1559.  *  mmi_prov_oma_exit_enter_pin
  1560.  * DESCRIPTION
  1561.  *  Exit handler for the OMA Enter Pin screen
  1562.  * PARAMETERS
  1563.  *  void
  1564.  * RETURNS
  1565.  *  void
  1566.  *****************************************************************************/
  1567. void mmi_prov_oma_exit_enter_pin(void)
  1568. {
  1569.     /*----------------------------------------------------------------*/
  1570.     /* Local Variables                                                */
  1571.     /*----------------------------------------------------------------*/
  1572.     history Scr;    /* Variable to hold the history data */
  1574.     /*----------------------------------------------------------------*/
  1575.     /* Code Body                                                      */
  1576.     /*----------------------------------------------------------------*/
  1577.     Scr.scrnID = SCR_ID_PROV_OMA_ENTER_PIN;
  1578.     Scr.entryFuncPtr = mmi_prov_oma_entry_enter_pin;
  1579.     pfnUnicodeStrcpy((S8*) Scr.inputBuffer, (S8*) g_prov_password);
  1580.     GetCategoryHistory(Scr.guiBuffer);
  1581.     AddHistory(Scr);
  1582. }
  1585. /*****************************************************************************
  1586.  * FUNCTION
  1587.  *  mmi_prov_oma_pin_length_validation
  1588.  * DESCRIPTION
  1589.  *  It checks if the Min. required PIN digits are been entered or not
  1590.  * PARAMETERS
  1591.  *  text_p          [?]         
  1592.  *  cursor_p        [?]         
  1593.  *  length          [IN]        
  1594.  * RETURNS
  1595.  *  void
  1596.  *****************************************************************************/
  1597. void mmi_prov_oma_pin_length_validation(U8 *text_p, U8 *cursor_p, S32 length)
  1598. {
  1599.     /*----------------------------------------------------------------*/
  1600.     /* Local Variables                                                */
  1601.     /*----------------------------------------------------------------*/
  1603.     /*----------------------------------------------------------------*/
  1604.     /* Code Body                                                      */
  1605.     /*----------------------------------------------------------------*/
  1606.     if ((length) < PROV_OMA_MIN_PASSWORD_LENGTH)
  1607.     {
  1608.         ChangeLeftSoftkey(0, 0);
  1609.         ClearKeyHandler(KEY_POUND, KEY_EVENT_UP);
  1610.     }
  1611.     else
  1612.     {
  1613.         EnableLeftSoftkey(STR_GLOBAL_OK, IMG_GLOBAL_OK);
  1614.         SetKeyHandler(mmi_prov_oma_validate_entered_pin, KEY_POUND, KEY_EVENT_UP);
  1615.     }
  1617. }
  1620. /*****************************************************************************
  1621.  * FUNCTION
  1622.  *  mmi_prov_oma_validate_entered_pin
  1623.  * DESCRIPTION
  1624.  *  This API will validate the PIN entered by the user
  1625.  * PARAMETERS
  1626.  *  void
  1627.  * RETURNS
  1628.  *  void
  1629.  *****************************************************************************/
  1630. void mmi_prov_oma_validate_entered_pin(void)
  1631. {
  1632.     /*----------------------------------------------------------------*/
  1633.     /* Local Variables                                                */
  1634.     /*----------------------------------------------------------------*/
  1636.     /*----------------------------------------------------------------*/
  1637.     /* Code Body                                                      */
  1638.     /*----------------------------------------------------------------*/
  1639.     /* U8 HMAC_value[41]; */
  1641.     /* this API will */
  1643.     /* take         gSecuritySetupContext.Password   & the  Prov Doc & give it to the HMAC calculation algo SHA-1 */
  1645.     //HMAC_value=certicomHMAC(g_prov_password,prov_buff_p);
  1646.     //Now compare with teh HMAC received in the DOc
  1648.     /* if the password entered is correct */
  1649.     mmi_prov_oma_save_received_settings(g_prov_oma_buff_p, g_prov_oma_buff_len);
  1650.     //display popup for the authentication done 
  1651.     //      g_prov_settings_present=0x01;
  1652.     //      DisplayPopup ((PU8)GetString(STR_ID_PROV_AUTHENTICATION_PASSED), IMG_ID_PROV_AUTHENTICATION_PASSED, 1, PROV_AUTHENTICATION_DONE_TIMEOUT,0);
  1653.     //      DeleteUptoScrID(IDLE_SCREEN_ID);
  1655.     //else if password entered is not ok
  1656.     //      DisplayPopup ((PU8)GetString(STR_ID_PROV_WRONG_PIN_ENTERED), IMG_ID_PROV_WRONG_PIN_ENTERED, 1, PROV_WRONG_PIN_ENTERED_TIMEOUT,0);
  1658. }
  1661. /*****************************************************************************
  1662.  * FUNCTION
  1663.  *  mmi_prov_oma_get_imsi_req
  1664.  * DESCRIPTION
  1665.  *  To send message MSG_ID_MMI_SMU_GET_IMSI_REQ
  1666.  *  in response of this message imsi field is returned
  1667.  * PARAMETERS
  1668.  *  void
  1669.  * RETURNS
  1670.  *  void
  1671.  *****************************************************************************/
  1672. void mmi_prov_oma_get_imsi_req(void)
  1673. {
  1674.     /*----------------------------------------------------------------*/
  1675.     /* Local Variables                                                */
  1676.     /*----------------------------------------------------------------*/
  1677.     MYQUEUE Message;
  1679.     /*----------------------------------------------------------------*/
  1680.     /* Code Body                                                      */
  1681.     /*----------------------------------------------------------------*/
  1682.     SetProtocolEventHandler(mmi_prov_oma_get_imsi_rsp, PRT_GET_IMSI_RSP);
  1684.     PRINT_INFORMATION(("@@@@@ Request To get the IMSI  @@@@@"));
  1685.     Message.oslSrcId = MOD_MMI;
  1686.     Message.oslDestId = MOD_L4C;
  1687.     Message.oslMsgId = PRT_GET_IMSI_REQ;
  1688.     Message.oslDataPtr = NULL;
  1689.     Message.oslPeerBuffPtr = NULL;
  1690.     OslMsgSendExtQueue(&Message);
  1691. }
  1694. /*****************************************************************************
  1695.  * FUNCTION
  1696.  *  mmi_prov_oma_get_imsi_rsp
  1697.  * DESCRIPTION
  1698.  *  This handles the imsi response returned by L4
  1699.  * PARAMETERS
  1700.  *  msg_p       [IN]        
  1701.  * RETURNS
  1702.  *  void
  1703.  *****************************************************************************/
  1704. void mmi_prov_oma_get_imsi_rsp(void *msg_p)
  1705. {
  1706.     /*----------------------------------------------------------------*/
  1707.     /* Local Variables                                                */
  1708.     /*----------------------------------------------------------------*/
  1709.     mmi_smu_get_imsi_rsp_struct *local_data_p = (mmi_smu_get_imsi_rsp_struct*) msg_p;
  1711.     /*----------------------------------------------------------------*/
  1712.     /* Code Body                                                      */
  1713.     /*----------------------------------------------------------------*/
  1714.     PRINT_INFORMATION(("Inside RspToTestRoamingEnabled"));
  1716.     if (local_data_p->result == ST_SUCCESS)
  1717.     {
  1718.         /* store the IMSI obtained */
  1719.         g_prov_imsi_p = jdd_MemAlloc(17, 1);    /* check the size */
  1721.         strcpy((S8*) g_prov_imsi_p, (S8*) local_data_p->imsi);
  1722.         //call the certicom HMAC alogo
  1723.         //compare the MAC value returned with teh one  stored from doc g_prov_MAC_value_p.......
  1724.     }
  1725.     /* if HMAC matches */
  1726.     mmi_prov_oma_save_received_settings(g_prov_oma_buff_p, g_prov_oma_buff_len);
  1727. }
  1729. // MAUI_00355388 Added
  1730. /*****************************************************************************
  1731.  * FUNCTION
  1732.  *  mmi_prov_oma_update_wap_profile_homepage_url
  1733.  * DESCRIPTION
  1734.  *  To update homepage url of WAP profile
  1735.  * PARAMETERS
  1736.  *  JC_UINT8 *       [IN]        
  1737.  * RETURNS
  1738.  *  void
  1739.  *****************************************************************************/
  1740. void mmi_prov_oma_update_wap_profile_homepage_url(JC_UINT8 *uri)
  1741. {
  1742.     U32 len = 0;
  1744. len = strlen((S8*) uri);
  1745. if (len >= PROV_PROFILE_HOMEPAGE_URL_LEN)
  1746. {
  1747. len = PROV_PROFILE_HOMEPAGE_URL_LEN - 1;
  1748. }
  1750. if (jdi_isValidUrl((JC_UINT8*) uri))
  1751. {
  1752. strcpy((S8*) g_ph_wap_profile_p->homepage_url, (S8*) uri);
  1753. g_ph_wap_profile_p->homepage_url[len] = '';
  1755. if (mmi_prov_check_if_substring((PS8) g_ph_wap_profile_p->homepage_url, (PS8) "http://") != 0x00)
  1756. {
  1757. S8 homepage[PROV_PROFILE_HOMEPAGE_URL_LEN + 10] = "http://";
  1759. strcat(homepage, (PS8) g_ph_wap_profile_p->homepage_url);
  1760. memset(g_ph_wap_profile_p->homepage_url, 0, PROV_PROFILE_HOMEPAGE_URL_LEN);
  1761. len = strlen(homepage);
  1762. if (len >= PROV_PROFILE_HOMEPAGE_URL_LEN)
  1763. {
  1764. len = PROV_PROFILE_HOMEPAGE_URL_LEN - 1;
  1765. }
  1766. memcpy(g_ph_wap_profile_p->homepage_url, homepage, len);
  1767. g_ph_wap_profile_p->homepage_url[len] = '';
  1768. }
  1769. }
  1770. else
  1771. {
  1772. S8 *default_url = "http://";
  1773.            
  1774. memset(g_ph_wap_profile_p->homepage_url, 0, PROV_PROFILE_HOMEPAGE_URL_LEN);
  1775. strcpy((PS8) g_ph_wap_profile_p->homepage_url, default_url);
  1776. }
  1777. }
  1779. /*****************************************************************************
  1780.  * FUNCTION
  1781.  *  mmi_prov_oma_update_mms_profile_mmsc_url
  1782.  * DESCRIPTION
  1783.  *  To update mmsc url of MMS profile
  1784.  * PARAMETERS
  1785.  *  JC_UINT8 *       [IN]        
  1786.  * RETURNS
  1787.  *  void
  1788.  *****************************************************************************/
  1789. void mmi_prov_oma_update_mms_profile_mmsc_url(JC_UINT8* uri)
  1790. {
  1791.     U32 len = 0;
  1792.     
  1793. len = strlen((S8*) uri);
  1794. if (len >= PROV_PROFILE_MMSC_URL_LEN)
  1795. {
  1796. len = PROV_PROFILE_MMSC_URL_LEN - 1;
  1797. }
  1799. if (jdi_isValidUrl((JC_UINT8*) uri))
  1800. {
  1801.     strcpy((S8*) g_ph_mms_profile_p->mmsc_url, (S8*) uri);
  1802. g_ph_mms_profile_p->mmsc_url[len] = '';
  1804. if (mmi_prov_check_if_substring((PS8) g_ph_mms_profile_p->mmsc_url, (PS8) "http://") != 0x00)
  1805. {
  1806. S8 homepage[PROV_PROFILE_MMSC_URL_LEN + 10] = "http://";
  1808.     strcat(homepage, (PS8) g_ph_mms_profile_p->mmsc_url);
  1809.             memset(g_ph_mms_profile_p->mmsc_url, 0, PROV_PROFILE_MMSC_URL_LEN);
  1810.         len = strlen(homepage);
  1811. if (len >= PROV_PROFILE_MMSC_URL_LEN)
  1812. {
  1813. len = PROV_PROFILE_MMSC_URL_LEN - 1;
  1814. }
  1815. memcpy(g_ph_mms_profile_p->mmsc_url, homepage, len);
  1816. g_ph_mms_profile_p->mmsc_url[len] = '';
  1817. }
  1818. }
  1819. else
  1820. {
  1821. S8 *default_url = "http://";
  1822. memset(g_ph_mms_profile_p->mmsc_url, 0, PROV_PROFILE_MMSC_URL_LEN);
  1823. strcpy((PS8) g_ph_mms_profile_p->mmsc_url, default_url);
  1824. }
  1825. }
  1826. // MAUI_00355388 End
  1829. #endif /* defined (JATAAYU_SUPPORT) && (defined (WAP_SUPPORT) || (defined (MMS_SUPPORT))) */ 
  1830. #endif /* _JPROVOMA_C */