mfw_sim.~c

GSM手机设计软件代码

		}

    //PATCH1 TB 1310: replace slen by llen
		if ((lang != NULL) && (llen != NULL))
		{
			l = sizeof(sim_config.pref_lang);
			if (l < *llen)
					*llen = l;
			memcpy(lang, sim_config.pref_lang, *llen);
		}
		//END PATCH1 TB

		if (access != NULL)
		{
			access->access_acm    = sim_cvt_access_status(sim_config.access_acm);
			access->access_acmmax = sim_cvt_access_status(sim_config.access_acmmax);
			access->access_puct   = sim_cvt_access_status(sim_config.access_puct);
		}
		//END PATCH2 TB

    return MFW_SIM_SUCCESS;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
| STATE   : code                        ROUTINE : sim_status_check   |
+--------------------------------------------------------------------+

  PURPOSE : check activation of SIM card

*/

int sim_status_check (void)
{
    TRACE_FUNCTION("sim_status_check()");

    return sim_stat;
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
| STATE   : code                        ROUTINE : sim_pin_count      |
+--------------------------------------------------------------------+

  PURPOSE : Request PIN/PUK count

*/

int sim_pin_count(U8 pin_id)
{
    SHORT        pn1Cnt;
    SHORT        pn2Cnt;
    SHORT        pk1Cnt;
    SHORT        pk2Cnt;
    T_ACI_PVRF_STAT ps1;
    T_ACI_PVRF_STAT ps2;
        
    TRACE_FUNCTION("sim_pin_count()");


    if (qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt,
                        &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2) != AT_CMPL)
        return -1;

    switch (pin_id)
    {
        case MFW_SIM_PIN1:  return pn1Cnt;
        case MFW_SIM_PIN2:  return pn2Cnt;
        case MFW_SIM_PUK1:  return pk1Cnt;
        case MFW_SIM_PUK2:  return pk2Cnt;
        default:            return -1;
    }
}


/*
+--------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
| STATE   : code                        ROUTINE : simDecodeB2A       |
+--------------------------------------------------------------------+

  PURPOSE : convert bcd to ASCII

*/

void simDecodeB2A (U8 *ci, U8 li, U8 *di)
{
    int i;
    
    TRACE_FUNCTION("simDecodeB2A()");

    for (i = 0; i < li * 2; i++)
    {
        di[i] = (i & 1) ? (ci[i/2] >> 4) + '0'
                        : (ci[i/2] & 0x0f) + '0';
        if (di[i] > '9')
        {
            di[i] = 0;
            break;
        }
    }
    di[i] = 0;
}


/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
| STATE   : code                        ROUTINE : sim_unlock_sim_lock |
+---------------------------------------------------------------------+

  PURPOSE : de-personalisation for SIM lock.

*/

T_MFW sim_unlock_sim_lock(UBYTE type, UBYTE *passwd)
{
  UBYTE        eep_ckey [LONG_NAME];  // extracted version of PCM content          
  EF_SIMLCKEXT simlck;

  TRACE_FUNCTION("sim_unlock_sim_lock()");

  /*
   * Read SIM LOCK Record from PCM
   */
  if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
  {
    TRACE_ERROR("No SIMLCK");
    return MFW_SIM_UNLOCK_ERR;
  }

  /*
   * check whether card is already blocked
   */
	if (simlck.cnt >= simlck.maxcnt)
		return MFW_SIM_BLOCKED;

  switch (type)
  {
    /*
     * N-Lock
     */
    case MFW_SIM_NLOCK:
      /*
       * Extract Key from PCM record
       */
      simDecodeB2A (simlck.NKey, 8, eep_ckey);
      if (!strcmp((char *)eep_ckey, (char *)passwd))
			{
        /*
         * unblock password is okay
         */
				sim_nlock     = SIMLOCK_ENABLED;
				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nlock,sim_nlock);
				simlck.cnt    = 0;
				sim_set_sim_lock (&simlck);

				return MFW_SIM_NLOCK;
			}
			break;

    /*
     * SP-Lock
     */
    case MFW_SIM_SPLOCK:
      /*
       * Extract Key from PCM record
       */
      simDecodeB2A (simlck.SPKey, 8, eep_ckey);
      if (!strcmp((char *)eep_ckey, (char *)passwd))
      {
        /*
         * unblock password is okay
         */
				sim_splock    = SIMLOCK_ENABLED;
				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
				simlck.cnt    = 0;
				sim_set_sim_lock (&simlck);

        return MFW_SIM_SPLOCK;
			}
			break;
    
    /*
     * NS-Lock
     */
    case MFW_SIM_NSLOCK:
      /*
       * Extract Key from PCM record
       */
      simDecodeB2A (simlck.NSKey, 8, eep_ckey);
      if (!strcmp((char *)eep_ckey, (char *)passwd))
      {
        /*
         * unblock password is okay
         */
   			sim_nslock    = SIMLOCK_ENABLED;
				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nslock,sim_nslock);
				simlck.cnt    = 0;
				sim_set_sim_lock (&simlck);

				return MFW_SIM_NSLOCK;
			}
			break;

    /*
     * C-Lock
     */
    case MFW_SIM_CLOCK:
      /*
       * Extract Key from PCM record
       */
      simDecodeB2A (simlck.CKey, 8, eep_ckey);
      if (!strcmp((char *)eep_ckey, (char *)passwd))
      {
        /*
         * unblock password is okay
         */
				sim_clock     = SIMLOCK_ENABLED;
				simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
				simlck.cnt    = 0;
				sim_set_sim_lock (&simlck);

				return MFW_SIM_CLOCK;
			}
			break;

    /*
     * P-Lock
     */
    case MFW_SIM_PLOCK:
      /*
       * Extract Key from PCM record
       */
      simDecodeB2A (simlck.PKey, 8, eep_ckey);
      if (!strcmp((char *)eep_ckey, (char *)passwd))
      {
        /*
         * unblock password is correct
         */
				sim_plock     = SIMLOCK_ENABLED;
				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
				simlck.cnt    = 0;
				sim_set_sim_lock (&simlck);

				return MFW_SIM_PLOCK;
			}
			break;

    default:
      return MFW_SIM_UNLOCK_ERR;
  }

  /*
   * another failed attempt
   * increment counter, store in PCM and may change the status
   */
	simlck.cnt++;
	sim_set_sim_lock (&simlck);

	if (simlck.cnt >= simlck.maxcnt)
	{
		sim_blocked = TRUE;    
		return MFW_SIM_BLOCKED;
	}
	else
		return MFW_SIM_UNLOCK_ERR;
}

/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
| STATE   : code                        ROUTINE : sim_check_sim_Plock |
+---------------------------------------------------------------------+

  PURPOSE : check SIM lock

*/

int sim_check_sim_Plock (void)
{
  EF_SIMLCKEXT simlck;
  UBYTE        i;

  TRACE_FUNCTION ("sim_check_sim_Plock()");


	if (sim_blocked EQ TRUE OR 
      sim_plock   EQ SIMLOCK_BLOCKED)
  {
    /*
     * Try to reset unlock attempt counter
     */
    sim_check_unblock_sim (&simlck);
		return MFW_SIM_BLOCKED;
  }

  /* 
   * lock check disabled      
   */
  if (sim_plock EQ SIMLOCK_DISABLED) 
    return MFW_SIM_DISABLE;

  /* 
   * lock check blocked      
   */
  if (sim_plock EQ SIMLOCK_LOCKED)              
    return MFW_SIM_LOCKED;

  /*
   * lock check enabled       
   */
  if (sim_plock EQ SIMLOCK_ENABLED)              
  {
    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
    {
      TRACE_ERROR("No SIMLCK");
      return MFW_SIM_FAILURE;     
    }

    /*
     * Check all digits
     */
		for (i=0; i<simlck.len_p_imsi; i++)
		{
			if (sim_check_imsi_digit(simlck.p_imsi[i], mfw_IMSI[i]) EQ FALSE)
				break;
		}
    
    /*
     * all digits okay
     */
		if (i EQ simlck.len_p_imsi)
			return MFW_SIM_ENABLE;

    /*
     * P-LOCK check failed
     */

    sim_plock     = SIMLOCK_LOCKED;
		simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
		sim_set_sim_lock (&simlck);
    return MFW_SIM_LOCKED;
  }

  /*
   * shall not happen
   */
  return MFW_SIM_FAILURE;
}


/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
| STATE   : code                        ROUTINE : sim_check_sim_Nlock |
+---------------------------------------------------------------------+

  PURPOSE : Check network lock

*/

int sim_check_sim_Nlock (void)
{
  EF_SIMLCKEXT simlck;
	UBYTE        i;

  TRACE_FUNCTION ("sim_check_sim_Nlock()");

	if (sim_blocked EQ TRUE OR 
      sim_nlock   EQ SIMLOCK_BLOCKED)
  {
    /*
     * Try to reset unlock attempt counter
     */
    sim_check_unblock_sim (&simlck);
		return MFW_SIM_BLOCKED;
  }

  /*
   * lock check disabled
   */
  if (sim_nlock EQ SIMLOCK_DISABLED)             
    return MFW_SIM_DISABLE;

  /*
   * lock check blocked
   */
  if (sim_nlock EQ SIMLOCK_LOCKED)            
        return MFW_SIM_LOCKED;

  /*
   * lock check enabled
   */
  if (sim_nlock EQ SIMLOCK_ENABLED)
  {
    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
    {
      TRACE_ERROR("No SIMLCK");
      return MFW_SIM_FAILURE;     
    }

    /*
     * check all digits
     */
		for (i=0; i<simlck.len_n_imsi; i++)	
    {
      if (sim_check_imsi_digit(simlck.n_imsi[i], mfw_IMSI[i]) EQ FALSE)
				break;
		}

    /*
     * all digits okay
     */
		if (i EQ simlck.len_n_imsi)
			return MFW_SIM_ENABLE;

    /*
     * N-LOCK check failed
     */
    sim_nlock     = SIMLOCK_LOCKED;
		simlck.locks1 = (U8) FldSet(simlck.locks1,nlock,sim_nlock);
		sim_set_sim_lock (&simlck);
    return MFW_SIM_LOCKED;
  }
  /*
   * shall not happen
   */
  return MFW_SIM_FAILURE;
}


/*
+---------------------------------------------------------------------+
| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
| STATE   : code                        ROUTINE : sim_check_sim_SPlock|
+---------------------------------------------------------------------+

  PURPOSE : Check SIM service provider lock. It only works with SIMs
            which support GID1 file.

*/

int sim_check_sim_SPlock (void)
{
  EF_SIMLCKEXT simlck;
	UBYTE        i;

  TRACE_FUNCTION ("sim_check_sim_SPlock()");

  /*
   * Only if Service 15 is activated and allocated
   */
  if (sim_check_service(15,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
    return MFW_SIM_FAILURE;

	if (sim_blocked EQ TRUE OR 
      sim_splock  EQ SIMLOCK_BLOCKED)
  {
    /*
     * Try to reset unlock attempt counter
     */
    sim_check_unblock_sim (&simlck);
		return MFW_SIM_BLOCKED;
  }

  /*
   * lock check disabled
   */
  if (sim_splock EQ SIMLOCK_DISABLED)
    return MFW_SIM_DISABLE;

  /*
   * lock check blocked
   */
  if (sim_splock EQ SIMLOCK_LOCKED)
    return MFW_SIM_LOCKED;

  /*
   * lock check enabled
   */
  if (sim_splock EQ SIMLOCK_ENABLED)             
  {
    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)