le_sim_interface.h

Go to the documentation of this file.
    1 
    2 
    3 /*
    4  * ====================== WARNING ======================
    5  *
    6  * THE CONTENTS OF THIS FILE HAVE BEEN AUTO-GENERATED.
    7  * DO NOT MODIFY IN ANY WAY.
    8  *
    9  * ====================== WARNING ======================
   10  */
   11 
   12 /**
   13  * @page c_sim SIM
   14  *
   15  * @ref le_sim_interface.h "API Reference" <br>
   16  * @ref platformConstraintsSim "SIM constraints"
   17  *
   18  * <HR>
   19  *
   20  * This file contains prototype definitions for SIM API.
   21  *
   22  * A subscriber identity module or subscriber identification module (SIM) is an integrated circuit
   23  * that securely stores the international mobile subscriber identity (IMSI) and related key used
   24  * to identify and authenticate subscribers on M2M devices.
   25  *
   26  * Most SIM cards can store a number of SMS messages and phone book contacts.
   27  *
   28  * le_sim_GetSelectedCard() returns the selected SIM card number.
   29  *
   30  * @section le_sim_binding IPC interfaces binding
   31  *
   32  * All the functions of this API are provided by the @b modemService.
   33  *
   34  * Here's a code sample binding to modem services:
   35  * @verbatim
   36    bindings:
   37    {
   38       clientExe.clientComponent.le_sim -> modemService.le_sim
   39    }
   40    @endverbatim
   41  *
   42  *
   43  * @section le_sim_SelectCard Select a card to use
   44  * le_sim_SelectCard() function is used to select the SIM. By default, the SIM in slot 1 is used.
   45  * @note The SIM selection is not reset persistent; this function has to be called at each start-up.
   46  *
   47  * @note: It is recommended to wait for a SIM handler notification after a new SIM selection before
   48  * calling le_sim API functions.
   49  *
   50  * A sample code can be seen in the following page:
   51  * - @subpage c_simTestSelect
   52  *
   53  * @section le_sim_id SIM identification information
   54  * \b ICCID:
   55  * Each SIM is internationally identified by its integrated circuit card identifier (ICCID). ICCIDs
   56  * are stored in the SIM cards and engraved or printed on the SIM card body.
   57  * The ICCID is defined by the ITU-T recommendation E.118 as the
   58  * Primary Account Number. According to E.118, the number is up to 19 digits long, including a
   59  * single check digit calculated using the Luhn algorithm. However, the GSM Phase 1 (ETSI
   60  * Recommendation GSM 11.11) defined the ICCID length as 10 octets (20 digits) with
   61  * operator-specific structure.
   62  *
   63  * le_sim_GetICCID() API reads the identification number (ICCID).
   64  *
   65  * Using this API selects the requested SIM.
   66  *
   67  * \b IMSI:
   68  * The International Mobile Subscriber Identity or IMSI is a unique identification associated with
   69  * all cellular networks. The IMSI is used in any mobile network that connects with other
   70  * networks. For GSM, UMTS and LTE network, this number is provisioned in the SIM card.
   71  *
   72  * An IMSI is usually presented as a 15 digit long number, but can be shorter. The first 3 digits
   73  * are the mobile country code (MCC), are followed by the mobile network code (MNC), either 2
   74  * digits (European standard) or 3 digits (North American standard). The length of the MNC depends
   75  * on the value of the MCC. The remaining digits are the mobile subscription identification number
   76  * (MSIN) within the network's customer base.
   77  *
   78  * \b Home \b Network \b Name:
   79  * le_sim_GetHomeNetworkOperator() retrieves the Home Network Name.
   80  *
   81  * le_sim_GetIMSI() API reads the international mobile subscriber identity (IMSI).
   82  *
   83  * Using this API selects the requested SIM.
   84  *
   85  * \b Phone \b Number:
   86  * le_sim_GetSubscriberPhoneNumber() API reads the Phone Number associated to the SIM.
   87  * If the phone number has not been provisioned, it will return the empty string.
   88  *
   89  * Using this API selects the requested SIM.
   90  *
   91  * \b Home \b Network \b Information:
   92  * - le_sim_GetHomeNetworkOperator()function retrieves the Home Network Name.
   93  * - le_sim_GetHomeNetworkMccMnc()function retrieves the Home Network MCC (Mobile Country Code)
   94  *      and MNC (Mobile Network Code).
   95  *
   96  * A sample code can be seen in the following page:
   97  * - @subpage c_simTestIdentification
   98  *
   99  * @section le_sim_auth SIM Authentication
  100  * le_sim_EnterPIN() enters the PIN (Personal Identification Number) code that's
  101  * required before any Mobile equipment functionality can be used.
  102  *
  103  * Using this API selects the requested SIM.
  104  *
  105  * le_sim_GetRemainingPINTries() returns the number of remaining PIN entry attempts
  106  * before the SIM will become blocked.
  107  *
  108  * Using this API selects the requested SIM.
  109  *
  110  * le_sim_GetRemainingPUKTries() returns the number of remaining PUK entry attempts
  111  * before the SIM will become blocked.
  112  *
  113  * Using this API selects the requested SIM.
  114  *
  115  * le_sim_ChangePIN() must be called to change the PIN code.
  116  *
  117  * Using this API selects the requested SIM.
  118  *
  119  *  le_sim_Lock() locks the SIM card: it enables requests for the PIN code.
  120  *
  121  * Using this API selects the requested SIM.
  122  *
  123  *  le_sim_Unlock() unlocks the SIM card: it disables requests for the PIN code.
  124  *
  125  * Using this API selects the requested SIM.
  126  *
  127  * le_sim_Unblock() unblocks the SIM card. The SIM card is blocked after X unsuccessful
  128  * attempts to enter the PIN. le_sim_Unblock() requires the PUK (Personal Unblocking) code
  129  * to set a new PIN code.
  130  *
  131  * A sample code can be seen in the following page:
  132  * - @subpage c_simTestAuthentication
  133  *
  134  * @section le_sim_state SIM states
  135  * le_sim_IsPresent() API advises the SIM is inserted (and locked) or removed.
  136  *
  137  * Using this API selects the requested SIM.
  138  *
  139  * le_sim_IsReady() API advises the SIM is ready (PIN code correctly entered
  140  * or not required).
  141  *
  142  * Using this API selects the requested SIM.
  143  *
  144  * The le_sim_GetState() API retrieves the SIM state:
  145  * - LE_SIM_INSERTED      : SIM card is inserted and locked.
  146  * - LE_SIM_ABSENT        : SIM card is absent.
  147  * - LE_SIM_READY         : SIM card is inserted and unlocked.
  148  * - LE_SIM_BLOCKED       : SIM card is blocked.
  149  * - LE_SIM_BUSY          : SIM card is busy.
  150  * - LE_SIM_STATE_UNKNOWN : Unknown SIM state.
  151  *
  152  * Using this API selects the requested SIM.
  153  *
  154  * A handler function must be registered to receive SIM's state notifications.
  155  * le_sim_AddNewStateHandler() API allows the User to register that handler.
  156  *
  157  * The handler must satisfy the following prototype:
  158  * typedef void(*le_sim_NewStateHandlerFunc_t)(@ref le_sim_Id_t simId, @c le_sim_States_t simState);
  159  *
  160  * When a new SIM's state is notified, the handler is called.
  161  *
  162  * Call le_sim_GetState() to retrieve the new state of the SIM.
  163  *
  164  * @note If two (or more) applications have registered a handler function for notifications, they
  165  * will all receive it and will be passed the same SIM.
  166  *
  167  * The application can uninstall the handler function by calling le_sim_RemoveNewStateHandler() API.
  168  *
  169  * @warning Your platform might need a reboot to detect a SIM insertion or removal.
  170  * Please refer to the @ref platformConstraintsSim "SIM constraints" page or your platform
  171  * documentation for further details.
  172  *
  173  * A sample code can be seen in the following page:
  174  * - @subpage c_simTestStates
  175  *
  176  * @section le_sim_profile_switch Local SIM profile switch
  177  *
  178  * As soon as there are several subscriptions/profiles in the eUICC (multi-profile), and one of
  179  * them is dedicated to emergency calls (ex: eCall, ERA-Glonass), local swap is needed to swap as
  180  * quickly as possible to the emergency profile in case of need.
  181  *
  182  * “Local swap” means that the User's application must be able to directly request the eUICC to
  183  * swap to Emergency Call Subscription (ECS).
  184  *
  185  * Local swap puts the eUICC in a temporary state, meaning the commercial subscription is replaced
  186  * by emergency subscription for a limited time, event triggering the swap back to commercial
  187  * subscription being controlled by the User's application.
  188  *
  189  * The le_sim_LocalSwapToEmergencyCallSubscription() function requests the multi-profile eUICC to
  190  * swap to ECS and to refresh. The User's application must wait for eUICC reboot to be finished and
  191  * network connection available.
  192  *
  193  * The le_sim_LocalSwapToCommercialSubscription() function requests the multi-profile eUICC to swap
  194  * back to commercial subscription and to refresh. The User's application must wait for eUICC reboot
  195  * to be finished and network connection available.
  196  *
  197  * The User's application can install an handler with le_sim_AddNewStateHandler() to receive eUICC's
  198  * state notifications.
  199  *
  200  * @warning
  201  * - If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be accepted with
  202  *   le_sim_AcceptSimToolkitCommand() in order to complete the profile swap procedure.
  203  * - If you use a Giesecke & Devrient (G&D) card, be sure that your platform has disabled
  204  *   security restrictions for channel management APDU commands, otherwise local SIM profile switch
  205  *   could not work.
  206  *
  207  * The le_sim_IsEmergencyCallSubscriptionSelected() function must be called to get the current
  208  * subscription.
  209  *
  210  * @warning There is no standard method to interrogate the current selected subscription. The
  211  * returned value of this function is based on the last executed local swap command. This means
  212  * that this function will always return LE_NOT_FOUND error at Legato startup.
  213  *
  214  * A sample code can be seen in the following page:
  215  * - @subpage c_simTestProfileSwitch
  216  *
  217  * @section le_sim_stk SIM Toolkit
  218  *
  219  * The SIM application Toolkit allows the SIM card to initiates commands or asking input from the
  220  * modem to accept/reject SIM operations.  See @ref platformConstraintsStk Constraints.
  221  *
  222  * One of the use case is the remote provisioning of an embedded UICC (eUICC).
  223  *
  224  * The embedded UICC (eUICC) format supports multiple subscription profiles, which can be remotely
  225  * provisioned, updated or selected through SIM tool kit procedures (Bearer Independent Protocol
  226  * -BIP-, SIM refresh).
  227  *
  228  * It is mainly used for in-vehicle emergency call service (eCall).
  229  *
  230  * An eUICC can be remotely managed to change the Mobile Network Operator subscription.
  231  *
  232  * The le_sim_AddSimToolkitEventHandler() function registers a handler to be notified of SIM
  233  * Toolkit events.
  234  *
  235  * The le_sim_RemoveSimToolkitEventHandler() function unregisters the handler.
  236  *
  237  * The le_sim_AcceptSimToolkitCommand() allows the device to accept the last SIM Toolkit command.
  238  *
  239  * The le_sim_RejectSimToolkitCommand() forbids the device to accept the last SIM Toolkit command.
  240  *
  241  * A sample code can be seen in the following page:
  242  * - @subpage c_simTestSimToolkit
  243  *
  244  * Information related to SIM Toolkit platform constraints can be seen in the
  245  * @subpage platformConstraintsStk page.
  246  *
  247  * @section le_sim_access SIM access
  248  *
  249  * The application can send an APDU (Application Protocol Data Unit) to the SIM using
  250  * le_sim_SendApdu() API. The user must encode the APDU as specified by in recommendation 3GPP
  251  * 11.11, 3GPP 51.011, 3GPP 31.102, 3GPP 31.103 or ETSI TS 102 221.
  252  * @note Between two successive call to le_sim_SendApdu() API, there is no locking
  253  * protection. In this situation, some command types and parameters can modify SIM files
  254  * incorrectly.
  255  *
  256  * Using le_sim_SendCommand(), the application has easier but more limited access to the
  257  * SIM database. The command is transmitted to the SIM, which gives information through swi1 and
  258  * swi2 about the execution of the command (see 3GPP recommendation previously mentioned for
  259  * their coding).
  260  * Some parameters are platform dependent, see @subpage platformConstraintsSim "SIM constraints" for
  261  * their coding.
  262  *
  263  * A sample code can be seen in the following page:
  264  * - @subpage c_simTestApdu
  265  *
  266  * <HR>
  267  *
  268  * Copyright (C) Sierra Wireless Inc.
  269  */
  270 /**
  271  * @file le_sim_interface.h
  272  *
  273  * Legato @ref c_sim include file.
  274  *
  275  * Copyright (C) Sierra Wireless Inc.
  276  */
  277 /**
  278  * @page c_simTestProfileSwitch Sample code for Local SIM profile switch
  279  *
  280  * @include "apps/test/modemServices/sim/simProfileSwap/simTestComp/simTest.c"
  281  */
  282 /**
  283  * @page c_simTestSimToolkit Sample code for Local SIM Toolkit
  284  *
  285  * @include "apps/test/modemServices/sim/simToolkit/simToolkitComp/simToolkitTest.c"
  286  */
  287 /**
  288  * @page c_simTestAuthentication Sample code for SIM Authentication
  289  *
  290  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Define
  291  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
  292  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Authentication
  293  */
  294 /**
  295  * @page c_simTestIdentification Sample code for SIM Identification
  296  *
  297  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
  298  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Identification
  299  */
  300 /**
  301  * @page c_simTestSelect Sample code for SIM Select
  302  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Select
  303  */
  304 /**
  305  * @page c_simTestStates Sample code for SIM States
  306  *
  307  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/main.c" Print
  308  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Display
  309  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" State handler
  310  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" State
  311  */
  312 /**
  313  * @page c_simTestApdu Sample code for SIM access
  314  * @snippet "apps/test/modemServices/sim/simIntegrationTest/simTestComp/simTest.c" Apdu
  315  */
  316 
  317 #ifndef LE_SIM_INTERFACE_H_INCLUDE_GUARD
  318 #define LE_SIM_INTERFACE_H_INCLUDE_GUARD
  319 
  320 
  321 #include "legato.h"
  322 
  323 // Interface specific includes
  324 #include "le_mdmDefs_interface.h"
  325 
  326 
  327 //--------------------------------------------------------------------------------------------------
  328 /**
  329  * Type for handler called when a server disconnects.
  330  */
  331 //--------------------------------------------------------------------------------------------------
  332 typedef void (*le_sim_DisconnectHandler_t)(void *);
  333 
  334 //--------------------------------------------------------------------------------------------------
  335 /**
  336  *
  337  * Connect the current client thread to the service providing this API. Block until the service is
  338  * available.
  339  *
  340  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  341  * called before any other functions in this API.  Normally, ConnectService is automatically called
  342  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  343  *
  344  * This function is created automatically.
  345  */
  346 //--------------------------------------------------------------------------------------------------
  347 void le_sim_ConnectService
  348 (
  349     void
  350 );
  351 
  352 //--------------------------------------------------------------------------------------------------
  353 /**
  354  *
  355  * Try to connect the current client thread to the service providing this API. Return with an error
  356  * if the service is not available.
  357  *
  358  * For each thread that wants to use this API, either ConnectService or TryConnectService must be
  359  * called before any other functions in this API.  Normally, ConnectService is automatically called
  360  * for the main thread, but not for any other thread. For details, see @ref apiFilesC_client.
  361  *
  362  * This function is created automatically.
  363  *
  364  * @return
  365  *  - LE_OK if the client connected successfully to the service.
  366  *  - LE_UNAVAILABLE if the server is not currently offering the service to which the client is
  367  *    bound.
  368  *  - LE_NOT_PERMITTED if the client interface is not bound to any service (doesn't have a binding).
  369  *  - LE_COMM_ERROR if the Service Directory cannot be reached.
  370  */
  371 //--------------------------------------------------------------------------------------------------
  372 le_result_t le_sim_TryConnectService
  373 (
  374     void
  375 );
  376 
  377 //--------------------------------------------------------------------------------------------------
  378 /**
  379  * Set handler called when server disconnection is detected.
  380  *
  381  * When a server connection is lost, call this handler then exit with LE_FATAL.  If a program wants
  382  * to continue without exiting, it should call longjmp() from inside the handler.
  383  */
  384 //--------------------------------------------------------------------------------------------------
  385 void le_sim_SetServerDisconnectHandler
  386 (
  387     le_sim_DisconnectHandler_t disconnectHandler,
  388     void *contextPtr
  389 );
  390 
  391 //--------------------------------------------------------------------------------------------------
  392 /**
  393  *
  394  * Disconnect the current client thread from the service providing this API.
  395  *
  396  * Normally, this function doesn't need to be called. After this function is called, there's no
  397  * longer a connection to the service, and the functions in this API can't be used. For details, see
  398  * @ref apiFilesC_client.
  399  *
  400  * This function is created automatically.
  401  */
  402 //--------------------------------------------------------------------------------------------------
  403 void le_sim_DisconnectService
  404 (
  405     void
  406 );
  407 
  408 
  409 //--------------------------------------------------------------------------------------------------
  410 /**
  411  * Minimum PIN length (4 digits)
  412  */
  413 //--------------------------------------------------------------------------------------------------
  414 #define LE_SIM_PIN_MIN_LEN 4
  415 
  416 //--------------------------------------------------------------------------------------------------
  417 /**
  418  * Maximum PIN length (8 digits)
  419  */
  420 //--------------------------------------------------------------------------------------------------
  421 #define LE_SIM_PIN_MAX_LEN 8
  422 
  423 //--------------------------------------------------------------------------------------------------
  424 /**
  425  * Maximum PIN length (8 digits)
  426  * One extra byte is added for the null character.
  427  */
  428 //--------------------------------------------------------------------------------------------------
  429 #define LE_SIM_PIN_MAX_BYTES 9
  430 
  431 //--------------------------------------------------------------------------------------------------
  432 /**
  433  * PUK length (8 digits)
  434  */
  435 //--------------------------------------------------------------------------------------------------
  436 #define LE_SIM_PUK_MAX_LEN 8
  437 
  438 //--------------------------------------------------------------------------------------------------
  439 /**
  440  * PUK length (8 digits)
  441  * One extra byte is added for the null character.
  442  */
  443 //--------------------------------------------------------------------------------------------------
  444 #define LE_SIM_PUK_MAX_BYTES 9
  445 
  446 //--------------------------------------------------------------------------------------------------
  447 /**
  448  * ICCID length
  449  * According to GSM Phase 1
  450  */
  451 //--------------------------------------------------------------------------------------------------
  452 #define LE_SIM_ICCID_LEN 20
  453 
  454 //--------------------------------------------------------------------------------------------------
  455 /**
  456  * ICCID length
  457  * One extra byte is added for the null character.
  458  */
  459 //--------------------------------------------------------------------------------------------------
  460 #define LE_SIM_ICCID_BYTES 21
  461 
  462 //--------------------------------------------------------------------------------------------------
  463 /**
  464  * IMSI length
  465  */
  466 //--------------------------------------------------------------------------------------------------
  467 #define LE_SIM_IMSI_LEN 15
  468 
  469 //--------------------------------------------------------------------------------------------------
  470 /**
  471  * IMSI length
  472  * One extra byte is added for the null character.
  473  */
  474 //--------------------------------------------------------------------------------------------------
  475 #define LE_SIM_IMSI_BYTES 16
  476 
  477 //--------------------------------------------------------------------------------------------------
  478 /**
  479  * APDU length
  480  */
  481 //--------------------------------------------------------------------------------------------------
  482 #define LE_SIM_APDU_MAX_BYTES 255
  483 
  484 //--------------------------------------------------------------------------------------------------
  485 /**
  486  * SIM response length
  487  */
  488 //--------------------------------------------------------------------------------------------------
  489 #define LE_SIM_RESPONSE_MAX_BYTES 256
  490 
  491 //--------------------------------------------------------------------------------------------------
  492 /**
  493  * SIM file identifier length
  494  */
  495 //--------------------------------------------------------------------------------------------------
  496 #define LE_SIM_FILE_ID_LEN 4
  497 
  498 //--------------------------------------------------------------------------------------------------
  499 /**
  500  * SIM file identifier length
  501  * One extra byte is added for the null character.
  502  */
  503 //--------------------------------------------------------------------------------------------------
  504 #define LE_SIM_FILE_ID_BYTES 5
  505 
  506 //--------------------------------------------------------------------------------------------------
  507 /**
  508  * SIM data command length
  509  *
  510  */
  511 //--------------------------------------------------------------------------------------------------
  512 #define LE_SIM_DATA_MAX_BYTES 100
  513 
  514 //--------------------------------------------------------------------------------------------------
  515 /**
  516  * SIM file path length
  517  */
  518 //--------------------------------------------------------------------------------------------------
  519 #define LE_SIM_PATH_MAX_LEN 100
  520 
  521 //--------------------------------------------------------------------------------------------------
  522 /**
  523  * SIM file path length
  524  * One extra byte is added for the null character.
  525  */
  526 //--------------------------------------------------------------------------------------------------
  527 #define LE_SIM_PATH_MAX_BYTES 101
  528 
  529 //--------------------------------------------------------------------------------------------------
  530 /**
  531  * SIM states.
  532  *
  533  */
  534 //--------------------------------------------------------------------------------------------------
  535 typedef enum
  536 {
  537     LE_SIM_INSERTED = 0,
  538         ///< SIM card is inserted and locked.
  539     LE_SIM_ABSENT = 1,
  540         ///< SIM card is absent.
  541     LE_SIM_READY = 2,
  542         ///< SIM card is inserted and unlocked.
  543     LE_SIM_BLOCKED = 3,
  544         ///< SIM card is blocked.
  545     LE_SIM_BUSY = 4,
  546         ///< SIM card is busy.
  547     LE_SIM_STATE_UNKNOWN = 5
  548         ///< Unknown SIM state.
  549 }
  550 le_sim_States_t;
  551 
  552 
  553 //--------------------------------------------------------------------------------------------------
  554 /**
  555  * SIM identifiers.
  556  *
  557  */
  558 //--------------------------------------------------------------------------------------------------
  559 typedef enum
  560 {
  561     LE_SIM_EMBEDDED = 0,
  562         ///< Embedded SIM
  563     LE_SIM_EXTERNAL_SLOT_1 = 1,
  564         ///< SIM inserted in external slot 1
  565     LE_SIM_EXTERNAL_SLOT_2 = 2,
  566         ///< SIM inserted in external slot 2
  567     LE_SIM_REMOTE = 3,
  568         ///< Remote SIM
  569     LE_SIM_ID_MAX = 4
  570         ///<
  571 }
  572 le_sim_Id_t;
  573 
  574 
  575 //--------------------------------------------------------------------------------------------------
  576 /**
  577  * Card Manufacturer.
  578  *
  579  */
  580 //--------------------------------------------------------------------------------------------------
  581 typedef enum
  582 {
  583     LE_SIM_OBERTHUR = 0,
  584         ///< Oberthur.
  585     LE_SIM_GEMALTO = 1,
  586         ///< Gemalto.
  587     LE_SIM_G_AND_D = 2,
  588         ///< G&D.
  589     LE_SIM_MORPHO = 3,
  590         ///< Morpho.
  591     LE_SIM_VALID = 4,
  592         ///< Valid.
  593     LE_SIM_MANUFACTURER_MAX = 5
  594         ///<
  595 }
  596 le_sim_Manufacturer_t;
  597 
  598 
  599 //--------------------------------------------------------------------------------------------------
  600 /**
  601  * SIM commands.
  602  */
  603 //--------------------------------------------------------------------------------------------------
  604 typedef enum
  605 {
  606     LE_SIM_READ_RECORD = 0,
  607         ///< Read a file record.
  608     LE_SIM_READ_BINARY = 1,
  609         ///< Read a transparent elementary file.
  610     LE_SIM_UPDATE_RECORD = 2,
  611         ///< Update a file record.
  612     LE_SIM_UPDATE_BINARY = 3,
  613         ///< Update a transparent elementary file.
  614     LE_SIM_COMMAND_MAX = 4
  615         ///< Max value
  616 }
  617 le_sim_Command_t;
  618 
  619 
  620 //--------------------------------------------------------------------------------------------------
  621 /**
  622  * SIM Toolkit events.
  623  */
  624 //--------------------------------------------------------------------------------------------------
  625 typedef enum
  626 {
  627     LE_SIM_OPEN_CHANNEL = 0,
  628         ///< SIM card ask to open a logical channel.
  629     LE_SIM_REFRESH = 1,
  630         ///< SIM card ask for a refresh.
  631     LE_SIM_STK_EVENT_MAX = 2
  632         ///< Unknown SIM Toolkit event.
  633 }
  634 le_sim_StkEvent_t;
  635 
  636 
  637 //--------------------------------------------------------------------------------------------------
  638 /**
  639  * Reference type used by Add/Remove functions for EVENT 'le_sim_NewState'
  640  */
  641 //--------------------------------------------------------------------------------------------------
  642 typedef struct le_sim_NewStateHandler* le_sim_NewStateHandlerRef_t;
  643 
  644 
  645 //--------------------------------------------------------------------------------------------------
  646 /**
  647  * Reference type used by Add/Remove functions for EVENT 'le_sim_SimToolkitEvent'
  648  */
  649 //--------------------------------------------------------------------------------------------------
  650 typedef struct le_sim_SimToolkitEventHandler* le_sim_SimToolkitEventHandlerRef_t;
  651 
  652 
  653 //--------------------------------------------------------------------------------------------------
  654 /**
  655  * Handler for sim state changes.
  656  *
  657  */
  658 //--------------------------------------------------------------------------------------------------
  659 typedef void (*le_sim_NewStateHandlerFunc_t)
  660 (
  661     le_sim_Id_t simId,
  662         ///< The SIM identifier.
  663     le_sim_States_t simState,
  664         ///< The SIM state.
  665     void* contextPtr
  666         ///<
  667 );
  668 
  669 //--------------------------------------------------------------------------------------------------
  670 /**
  671  * Handler for Sim Toolkit Events.
  672  *
  673  */
  674 //--------------------------------------------------------------------------------------------------
  675 typedef void (*le_sim_SimToolkitEventHandlerFunc_t)
  676 (
  677     le_sim_Id_t simId,
  678         ///< The SIM identifier.
  679     le_sim_StkEvent_t stkEvent,
  680         ///< The SIM state.
  681     void* contextPtr
  682         ///<
  683 );
  684 
  685 //--------------------------------------------------------------------------------------------------
  686 /**
  687  * Add handler function for EVENT 'le_sim_NewState'
  688  *
  689  * This event provides information on sim state changes.
  690  *
  691  */
  692 //--------------------------------------------------------------------------------------------------
  693 le_sim_NewStateHandlerRef_t le_sim_AddNewStateHandler
  694 (
  695     le_sim_NewStateHandlerFunc_t handlerPtr,
  696         ///< [IN]
  697     void* contextPtr
  698         ///< [IN]
  699 );
  700 
  701 //--------------------------------------------------------------------------------------------------
  702 /**
  703  * Remove handler function for EVENT 'le_sim_NewState'
  704  */
  705 //--------------------------------------------------------------------------------------------------
  706 void le_sim_RemoveNewStateHandler
  707 (
  708     le_sim_NewStateHandlerRef_t handlerRef
  709         ///< [IN]
  710 );
  711 
  712 //--------------------------------------------------------------------------------------------------
  713 /**
  714  * Add handler function for EVENT 'le_sim_SimToolkitEvent'
  715  *
  716  * This event provides information on Sim Toolkit application.
  717  *
  718  */
  719 //--------------------------------------------------------------------------------------------------
  720 le_sim_SimToolkitEventHandlerRef_t le_sim_AddSimToolkitEventHandler
  721 (
  722     le_sim_SimToolkitEventHandlerFunc_t handlerPtr,
  723         ///< [IN]
  724     void* contextPtr
  725         ///< [IN]
  726 );
  727 
  728 //--------------------------------------------------------------------------------------------------
  729 /**
  730  * Remove handler function for EVENT 'le_sim_SimToolkitEvent'
  731  */
  732 //--------------------------------------------------------------------------------------------------
  733 void le_sim_RemoveSimToolkitEventHandler
  734 (
  735     le_sim_SimToolkitEventHandlerRef_t handlerRef
  736         ///< [IN]
  737 );
  738 
  739 //--------------------------------------------------------------------------------------------------
  740 /**
  741  * Get the current selected card.
  742  *
  743  * @return Number of the current selected SIM card.
  744  */
  745 //--------------------------------------------------------------------------------------------------
  746 le_sim_Id_t le_sim_GetSelectedCard
  747 (
  748     void
  749 );
  750 
  751 //--------------------------------------------------------------------------------------------------
  752 /**
  753  * Select a SIM.
  754  *
  755  * @return LE_FAULT         Function failed to select the requested SIM
  756  * @return LE_OK            Function succeeded.
  757  *
  758  */
  759 //--------------------------------------------------------------------------------------------------
  760 le_result_t le_sim_SelectCard
  761 (
  762     le_sim_Id_t simId
  763         ///< [IN] The SIM identifier.
  764 );
  765 
  766 //--------------------------------------------------------------------------------------------------
  767 /**
  768  * Retrieves the integrated circuit card identifier (ICCID) of the SIM card (20 digits)
  769  *
  770  * @return LE_OK             ICCID was successfully retrieved.
  771  * @return LE_OVERFLOW       iccidPtr buffer was too small for the ICCID.
  772  * @return LE_BAD_PARAMETER if a parameter is invalid
  773  * @return LE_FAULT         The ICCID could not be retrieved.
  774  *
  775  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  776  *       function will not return.
  777  */
  778 //--------------------------------------------------------------------------------------------------
  779 le_result_t le_sim_GetICCID
  780 (
  781     le_sim_Id_t simId,
  782         ///< [IN] The SIM identifier.
  783     char* iccid,
  784         ///< [OUT] ICCID
  785     size_t iccidSize
  786         ///< [IN]
  787 );
  788 
  789 //--------------------------------------------------------------------------------------------------
  790 /**
  791  * Retrieves the identification number (IMSI) of the SIM card. (max 15 digits)
  792  *
  793  * @return LE_OVERFLOW      The imsiPtr buffer was too small for the IMSI.
  794  * @return LE_BAD_PARAMETER The parameters are invalid.
  795  * @return LE_FAULT         The function failed.
  796  * @return LE_TIMEOUT       No response was received.
  797  * @return LE_OK            The function succeeded.
  798  *
  799  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  800  *       function will not return.
  801  */
  802 //--------------------------------------------------------------------------------------------------
  803 le_result_t le_sim_GetIMSI
  804 (
  805     le_sim_Id_t simId,
  806         ///< [IN] The SIM identifier.
  807     char* imsi,
  808         ///< [OUT] IMSI
  809     size_t imsiSize
  810         ///< [IN]
  811 );
  812 
  813 //--------------------------------------------------------------------------------------------------
  814 /**
  815  * Verify if the SIM card is present or not.
  816  *
  817  * @return true   SIM card is present.
  818  * @return false  SIM card is absent
  819  *
  820  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  821  *       function will not return.
  822  */
  823 //--------------------------------------------------------------------------------------------------
  824 bool le_sim_IsPresent
  825 (
  826     le_sim_Id_t simId
  827         ///< [IN] The SIM identifier.
  828 );
  829 
  830 //--------------------------------------------------------------------------------------------------
  831 /**
  832  * Verify if the SIM is ready (PIN code correctly inserted or not
  833  * required).
  834  *
  835  * @return true   PIN is correctly inserted or not required.
  836  * @return false  PIN must be inserted
  837  *
  838  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  839  *       function will not return.
  840  */
  841 //--------------------------------------------------------------------------------------------------
  842 bool le_sim_IsReady
  843 (
  844     le_sim_Id_t simId
  845         ///< [IN] The SIM identifier.
  846 );
  847 
  848 //--------------------------------------------------------------------------------------------------
  849 /**
  850  * This function must be called to enter the PIN code.
  851  *
  852  * @return LE_BAD_PARAMETER The parameters are invalid.
  853  * @return LE_NOT_FOUND     The function failed to select the SIM card for this operation.
  854  * @return LE_UNDERFLOW     The PIN code is not long enough (min 4 digits).
  855  * @return LE_FAULT         The function failed to enter the PIN code.
  856  * @return LE_OK            The function succeeded.
  857  *
  858  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
  859  *       function will not return.
  860  *
  861  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  862  *       function will not return.
  863  */
  864 //--------------------------------------------------------------------------------------------------
  865 le_result_t le_sim_EnterPIN
  866 (
  867     le_sim_Id_t simId,
  868         ///< [IN] The SIM identifier.
  869     const char* pin
  870         ///< [IN] The PIN code.
  871 )
  872 __attribute__(( nonnull(2) ));
  873 
  874 //--------------------------------------------------------------------------------------------------
  875 /**
  876  * Change the PIN code.
  877  *
  878  * @return LE_NOT_FOUND     Function failed to select the SIM card for this operation.
  879  * @return LE_UNDERFLOW     PIN code is/are not long enough (min 4 digits).
  880  * @return LE_FAULT         Function failed to change the PIN code.
  881  * @return LE_OK            Function succeeded.
  882  *
  883  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
  884  *       function will not return.
  885  *
  886  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  887  *       function will not return.
  888  */
  889 //--------------------------------------------------------------------------------------------------
  890 le_result_t le_sim_ChangePIN
  891 (
  892     le_sim_Id_t simId,
  893         ///< [IN] The SIM identifier.
  894     const char* oldpin,
  895         ///< [IN] The old PIN code.
  896     const char* newpin
  897         ///< [IN] The new PIN code.
  898 )
  899 __attribute__(( nonnull(2,3) ));
  900 
  901 //--------------------------------------------------------------------------------------------------
  902 /**
  903  * Get the number of remaining PIN insertion tries.
  904  *
  905  * @return LE_NOT_FOUND     The function failed to select the SIM card for this operation.
  906  * @return LE_BAD_PARAMETER Invalid SIM identifier.
  907  * @return LE_FAULT         The function failed to get the number of remaining PIN insertion tries.
  908  * @return A positive value The function succeeded. The number of remaining PIN insertion tries.
  909  *
  910  */
  911 //--------------------------------------------------------------------------------------------------
  912 int32_t le_sim_GetRemainingPINTries
  913 (
  914     le_sim_Id_t simId
  915         ///< [IN] The SIM identifier.
  916 );
  917 
  918 //--------------------------------------------------------------------------------------------------
  919 /**
  920  * Get the number of remaining PUK insertion tries.
  921  *
  922  * @return LE_OK            On success.
  923  * @return LE_NOT_FOUND     The function failed to select the SIM card for this operation.
  924  * @return LE_BAD_PARAMETER Invalid SIM identifier.
  925  * @return LE_FAULT         The function failed to get the number of remaining PUK insertion tries.
  926  *
  927  * @note If the caller is passing an null pointer to this function, it is a fatal error
  928  *       and the function will not return.
  929  *
  930  */
  931 //--------------------------------------------------------------------------------------------------
  932 le_result_t le_sim_GetRemainingPUKTries
  933 (
  934     le_sim_Id_t simId,
  935         ///< [IN] The SIM identifier.
  936     uint32_t* remainingPukTriesPtrPtr
  937         ///< [OUT] The number of remaining PUK insertion tries.
  938 );
  939 
  940 //--------------------------------------------------------------------------------------------------
  941 /**
  942  * Unlock the SIM card: it disables the request of the PIN code.
  943  *
  944  * @return LE_NOT_FOUND     Function failed to select the SIM card for this operation.
  945  * @return LE_UNDERFLOW     PIN code is not long enough (min 4 digits).
  946  * @return LE_FAULT         The function failed to unlock the SIM card.
  947  * @return LE_OK            Function succeeded.
  948  *
  949  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
  950  *       function will not return.
  951  *
  952  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  953  *       function will not return.
  954  */
  955 //--------------------------------------------------------------------------------------------------
  956 le_result_t le_sim_Unlock
  957 (
  958     le_sim_Id_t simId,
  959         ///< [IN] The SIM identifier.
  960     const char* pin
  961         ///< [IN] The PIN code.
  962 )
  963 __attribute__(( nonnull(2) ));
  964 
  965 //--------------------------------------------------------------------------------------------------
  966 /**
  967  * Lock the SIM card: it enables the request of the PIN code.
  968  *
  969  * @return LE_NOT_FOUND     Function failed to select the SIM card for this operation.
  970  * @return LE_UNDERFLOW     PIN code is not long enough (min 4 digits).
  971  * @return LE_FAULT         The function failed to unlock the SIM card.
  972  * @return LE_OK            Function succeeded.
  973  *
  974  * @note If PIN code is too long (max 8 digits), it is a fatal error, the
  975  *       function will not return.
  976  *
  977  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
  978  *       function will not return.
  979  */
  980 //--------------------------------------------------------------------------------------------------
  981 le_result_t le_sim_Lock
  982 (
  983     le_sim_Id_t simId,
  984         ///< [IN] The SIM identifier.
  985     const char* pin
  986         ///< [IN] The PIN code.
  987 )
  988 __attribute__(( nonnull(2) ));
  989 
  990 //--------------------------------------------------------------------------------------------------
  991 /**
  992  * Unblock the SIM card.
  993  *
  994  * @return LE_NOT_FOUND     Function failed to select the SIM card for this operation.
  995  * @return LE_UNDERFLOW     PIN code is not long enough (min 4 digits).
  996  * @return LE_BAD_PARAMETER Invalid SIM identifier.
  997  * @return LE_OUT_OF_RANGE  PUK code length is not correct (8 digits).
  998  * @return LE_FAULT         The function failed to unlock the SIM card.
  999  * @return LE_OK            Function succeeded.
 1000  *
 1001  * @note If new PIN or puk code are too long (max 8 digits), it is a fatal error, the
 1002  *       function will not return.
 1003  *
 1004  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1005  *       function will not return.
 1006  */
 1007 //--------------------------------------------------------------------------------------------------
 1008 le_result_t le_sim_Unblock
 1009 (
 1010     le_sim_Id_t simId,
 1011         ///< [IN] The SIM identifier.
 1012     const char* puk,
 1013         ///< [IN] The PUK code.
 1014     const char* newpin
 1015         ///< [IN] The PIN code.
 1016 )
 1017 __attribute__(( nonnull(2,3) ));
 1018 
 1019 //--------------------------------------------------------------------------------------------------
 1020 /**
 1021  * Get the SIM state.
 1022  *
 1023  * @return Current SIM state.
 1024  *
 1025  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1026  *       function will not return.
 1027  */
 1028 //--------------------------------------------------------------------------------------------------
 1029 le_sim_States_t le_sim_GetState
 1030 (
 1031     le_sim_Id_t simId
 1032         ///< [IN] The SIM identifier.
 1033 );
 1034 
 1035 //--------------------------------------------------------------------------------------------------
 1036 /**
 1037  * Get the SIM Phone Number.
 1038  *
 1039  * @return
 1040  *      - LE_OK on success
 1041  *      - LE_OVERFLOW if the Phone Number can't fit in phoneNumberStr
 1042  *      - LE_BAD_PARAMETER if a parameter is invalid
 1043  *      - LE_FAULT on any other failure
 1044  *
 1045  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1046  *       function will not return.
 1047  */
 1048 //--------------------------------------------------------------------------------------------------
 1049 le_result_t le_sim_GetSubscriberPhoneNumber
 1050 (
 1051     le_sim_Id_t simId,
 1052         ///< [IN] The SIM identifier.
 1053     char* phoneNumberStr,
 1054         ///< [OUT] The phone Number.
 1055     size_t phoneNumberStrSize
 1056         ///< [IN]
 1057 );
 1058 
 1059 //--------------------------------------------------------------------------------------------------
 1060 /**
 1061  * This function must be called to get the Home Network Name information.
 1062  *
 1063  * @return
 1064  *      - LE_OK on success
 1065  *      - LE_OVERFLOW if the Home Network Name can't fit in nameStr
 1066  *      - LE_NOT_FOUND if the network is not found
 1067  *      - LE_BAD_PARAMETER if a parameter is invalid
 1068  *      - LE_FAULT on any other failure
 1069  *
 1070  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1071  *       function will not return.
 1072  */
 1073 //--------------------------------------------------------------------------------------------------
 1074 le_result_t le_sim_GetHomeNetworkOperator
 1075 (
 1076     le_sim_Id_t simId,
 1077         ///< [IN] The SIM identifier.
 1078     char* nameStr,
 1079         ///< [OUT] the home network Name
 1080     size_t nameStrSize
 1081         ///< [IN]
 1082 );
 1083 
 1084 //--------------------------------------------------------------------------------------------------
 1085 /**
 1086  * This function must be called to get the Home Network MCC MNC.
 1087  *
 1088  * @return
 1089  *      - LE_OK on success
 1090  *      - LE_NOT_FOUND if Home Network has not been provisioned
 1091  *      - LE_FAULT for unexpected error
 1092  *
 1093  * @note If the caller is passing a bad pointer into this function, it is a fatal error, the
 1094  *       function will not return.
 1095  */
 1096 //--------------------------------------------------------------------------------------------------
 1097 le_result_t le_sim_GetHomeNetworkMccMnc
 1098 (
 1099     le_sim_Id_t simId,
 1100         ///< [IN] The SIM identifier.
 1101     char* mccPtr,
 1102         ///< [OUT] Mobile Country Code
 1103     size_t mccPtrSize,
 1104         ///< [IN]
 1105     char* mncPtr,
 1106         ///< [OUT] Mobile Network Code
 1107     size_t mncPtrSize
 1108         ///< [IN]
 1109 );
 1110 
 1111 //--------------------------------------------------------------------------------------------------
 1112 /**
 1113  * This function must be called to request the multi-profile eUICC to swap to ECS and to refresh.
 1114  * The User's application must wait for eUICC reboot to be finished and network connection
 1115  * available.
 1116  *
 1117  * @return
 1118  *      - LE_OK on success
 1119  *      - LE_BAD_PARAMETER invalid SIM identifier
 1120  *      - LE_BUSY when a profile swap is already in progress
 1121  *      - LE_FAULT for unexpected error
 1122  *
 1123  * @warning If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be
 1124  *          accepted with le_sim_AcceptSimToolkitCommand() in order to complete the profile swap
 1125  *          procedure.
 1126  */
 1127 //--------------------------------------------------------------------------------------------------
 1128 le_result_t le_sim_LocalSwapToEmergencyCallSubscription
 1129 (
 1130     le_sim_Id_t simId,
 1131         ///< [IN] The SIM identifier.
 1132     le_sim_Manufacturer_t manufacturer
 1133         ///< [IN] The card manufacturer.
 1134 );
 1135 
 1136 //--------------------------------------------------------------------------------------------------
 1137 /**
 1138  * This function must be called to request the multi-profile eUICC to swap back to commercial
 1139  * subscription and to refresh.
 1140  * The User's application must wait for eUICC reboot to be finished and network connection
 1141  * available.
 1142  *
 1143  * @return
 1144  *      - LE_OK on success
 1145  *      - LE_BAD_PARAMETER invalid SIM identifier
 1146  *      - LE_BUSY when a profile swap is already in progress
 1147  *      - LE_FAULT for unexpected error
 1148  *
 1149  * @warning If you use a Morpho or Oberthur card, the SIM_REFRESH PRO-ACTIVE command must be
 1150  *          accepted with le_sim_AcceptSimToolkitCommand() in order to complete the profile swap
 1151  *          procedure.
 1152  */
 1153 //--------------------------------------------------------------------------------------------------
 1154 le_result_t le_sim_LocalSwapToCommercialSubscription
 1155 (
 1156     le_sim_Id_t simId,
 1157         ///< [IN] The SIM identifier.
 1158     le_sim_Manufacturer_t manufacturer
 1159         ///< [IN] The card manufacturer.
 1160 );
 1161 
 1162 //--------------------------------------------------------------------------------------------------
 1163 /**
 1164  * This function must be called to get the current subscription.
 1165  *
 1166  * @return
 1167  *      - LE_OK on success
 1168  *      - LE_BAD_PARAMETER invalid SIM identifier
 1169  *      - LE_NOT_FOUND cannot determine the current selected subscription
 1170  *      - LE_FAULT for unexpected errors
 1171  *
 1172  * @warning There is no standard method to interrogate the current selected subscription. The
 1173  * returned value of this function is based on the last executed local swap command. This means
 1174  * that this function will always return LE_NOT_FOUND error at Legato startup.
 1175  */
 1176 //--------------------------------------------------------------------------------------------------
 1177 le_result_t le_sim_IsEmergencyCallSubscriptionSelected
 1178 (
 1179     le_sim_Id_t simId,
 1180         ///< [IN] The SIM identifier
 1181     bool* isEcsPtr
 1182         ///< [OUT] true if Emergency Call Subscription (ECS) is selected,
 1183         ///<       false if Commercial Subscription is selected
 1184 );
 1185 
 1186 //--------------------------------------------------------------------------------------------------
 1187 /**
 1188  * Accept the last SIM Toolkit command.
 1189  *
 1190  * @return LE_FAULT    Function failed.
 1191  * @return LE_OK       Function succeeded.
 1192  */
 1193 //--------------------------------------------------------------------------------------------------
 1194 le_result_t le_sim_AcceptSimToolkitCommand
 1195 (
 1196     le_sim_Id_t simId
 1197         ///< [IN] The SIM identifier.
 1198 );
 1199 
 1200 //--------------------------------------------------------------------------------------------------
 1201 /**
 1202  * Reject the last SIM Toolkit command.
 1203  *
 1204  * @return LE_FAULT     Function failed.
 1205  * @return LE_OK        Function succeeded.
 1206  */
 1207 //--------------------------------------------------------------------------------------------------
 1208 le_result_t le_sim_RejectSimToolkitCommand
 1209 (
 1210     le_sim_Id_t simId
 1211         ///< [IN] The SIM identifier.
 1212 );
 1213 
 1214 //--------------------------------------------------------------------------------------------------
 1215 /**
 1216  * Send APDU command to the SIM.
 1217  *
 1218  * @return
 1219  *      - LE_OK             Function succeeded.
 1220  *      - LE_FAULT          The function failed.
 1221  *      - LE_BAD_PARAMETER  A parameter is invalid.
 1222  *      - LE_NOT_FOUND      The function failed to select the SIM card for this operation.
 1223  */
 1224 //--------------------------------------------------------------------------------------------------
 1225 le_result_t le_sim_SendApdu
 1226 (
 1227     le_sim_Id_t simId,
 1228         ///< [IN] The SIM identifier.
 1229     const uint8_t* commandApduPtr,
 1230         ///< [IN] APDU command.
 1231     size_t commandApduSize,
 1232         ///< [IN]
 1233     uint8_t* responseApduPtr,
 1234         ///< [OUT] SIM response.
 1235     size_t* responseApduSizePtr
 1236         ///< [INOUT]
 1237 );
 1238 
 1239 //--------------------------------------------------------------------------------------------------
 1240 /**
 1241  * Send a command to the SIM.
 1242  *
 1243  * @return
 1244  *      - LE_OK             Function succeeded.
 1245  *      - LE_FAULT          The function failed.
 1246  *      - LE_BAD_PARAMETER  A parameter is invalid.
 1247  *      - LE_NOT_FOUND      - The function failed to select the SIM card for this operation
 1248  *                          - The requested SIM file is not found
 1249  *      - LE_OVERFLOW       Response buffer is too small to copy the SIM answer.
 1250  *      - LE_UNSUPPORTED    The platform does not support this operation.
 1251  */
 1252 //--------------------------------------------------------------------------------------------------
 1253 le_result_t le_sim_SendCommand
 1254 (
 1255     le_sim_Id_t simId,
 1256         ///< [IN] The SIM identifier.
 1257     le_sim_Command_t command,
 1258         ///< [IN] The SIM command.
 1259     const char* fileIdentifier,
 1260         ///< [IN] File identifier
 1261     uint8_t p1,
 1262         ///< [IN] Parameter P1 passed to the SIM
 1263     uint8_t p2,
 1264         ///< [IN] Parameter P2 passed to the SIM
 1265     uint8_t p3,
 1266         ///< [IN] Parameter P3 passed to the SIM
 1267     const uint8_t* dataPtr,
 1268         ///< [IN] data command.
 1269     size_t dataSize,
 1270         ///< [IN]
 1271     const char* path,
 1272         ///< [IN] path of the elementary file
 1273     uint8_t* sw1Ptr,
 1274         ///< [OUT] Status Word 1 received from the SIM
 1275     uint8_t* sw2Ptr,
 1276         ///< [OUT] Status Word 2 received from the SIM
 1277     uint8_t* responsePtr,
 1278         ///< [OUT] SIM response.
 1279     size_t* responseSizePtr
 1280         ///< [INOUT]
 1281 )
 1282 __attribute__(( nonnull(3,9) ));
 1283 
 1284 #endif // LE_SIM_INTERFACE_H_INCLUDE_GUARD
le_sim_AddNewStateHandler
le_sim_NewStateHandlerRef_t le_sim_AddNewStateHandler(le_sim_NewStateHandlerFunc_t handlerPtr, void *contextPtr)


LE_SIM_READ_BINARY
Read a transparent elementary file. 
Definition: le_sim_interface.h:608


le_sim_IsPresent
bool le_sim_IsPresent(le_sim_Id_t simId)


le_sim_GetHomeNetworkOperator
le_result_t le_sim_GetHomeNetworkOperator(le_sim_Id_t simId, char *nameStr, size_t nameStrSize)


le_sim_Id_t
le_sim_Id_t
Definition: le_sim_interface.h:559


le_sim_GetRemainingPUKTries
le_result_t le_sim_GetRemainingPUKTries(le_sim_Id_t simId, uint32_t *remainingPukTriesPtrPtr)


le_sim_SimToolkitEventHandlerFunc_t
void(* le_sim_SimToolkitEventHandlerFunc_t)(le_sim_Id_t simId, le_sim_StkEvent_t stkEvent, void *contextPtr)
Definition: le_sim_interface.h:676


le_result_t
le_result_t
Definition: le_basics.h:35


le_sim_Lock
le_result_t le_sim_Lock(le_sim_Id_t simId, const char *pin)


le_sim_LocalSwapToEmergencyCallSubscription
le_result_t le_sim_LocalSwapToEmergencyCallSubscription(le_sim_Id_t simId, le_sim_Manufacturer_t manufacturer)


le_mdmDefs_interface.h


le_sim_SendApdu
le_result_t le_sim_SendApdu(le_sim_Id_t simId, const uint8_t *commandApduPtr, size_t commandApduSize, uint8_t *responseApduPtr, size_t *responseApduSizePtr)


LE_SIM_BUSY
SIM card is busy. 
Definition: le_sim_interface.h:545


le_sim_StkEvent_t
le_sim_StkEvent_t
Definition: le_sim_interface.h:625


le_sim_GetHomeNetworkMccMnc
le_result_t le_sim_GetHomeNetworkMccMnc(le_sim_Id_t simId, char *mccPtr, size_t mccPtrSize, char *mncPtr, size_t mncPtrSize)


LE_SIM_UPDATE_BINARY
Update a transparent elementary file. 
Definition: le_sim_interface.h:612


le_sim_Unblock
le_result_t le_sim_Unblock(le_sim_Id_t simId, const char *puk, const char *newpin)


LE_SIM_EMBEDDED
Embedded SIM. 
Definition: le_sim_interface.h:561


LE_SIM_OBERTHUR
Oberthur. 
Definition: le_sim_interface.h:583


le_sim_States_t
le_sim_States_t
Definition: le_sim_interface.h:535


le_sim_SendCommand
le_result_t le_sim_SendCommand(le_sim_Id_t simId, le_sim_Command_t command, const char *fileIdentifier, uint8_t p1, uint8_t p2, uint8_t p3, const uint8_t *dataPtr, size_t dataSize, const char *path, uint8_t *sw1Ptr, uint8_t *sw2Ptr, uint8_t *responsePtr, size_t *responseSizePtr)


le_sim_SimToolkitEventHandlerRef_t
struct le_sim_SimToolkitEventHandler * le_sim_SimToolkitEventHandlerRef_t
Definition: le_sim_interface.h:650


le_sim_Unlock
le_result_t le_sim_Unlock(le_sim_Id_t simId, const char *pin)


LE_SIM_ABSENT
SIM card is absent. 
Definition: le_sim_interface.h:539


LE_SIM_INSERTED
SIM card is inserted and locked. 
Definition: le_sim_interface.h:537


LE_SIM_READ_RECORD
Read a file record. 
Definition: le_sim_interface.h:606


le_sim_NewStateHandlerFunc_t
void(* le_sim_NewStateHandlerFunc_t)(le_sim_Id_t simId, le_sim_States_t simState, void *contextPtr)
Definition: le_sim_interface.h:660


le_sim_GetICCID
le_result_t le_sim_GetICCID(le_sim_Id_t simId, char *iccid, size_t iccidSize)


le_sim_SetServerDisconnectHandler
void le_sim_SetServerDisconnectHandler(le_sim_DisconnectHandler_t disconnectHandler, void *contextPtr)


le_sim_AcceptSimToolkitCommand
le_result_t le_sim_AcceptSimToolkitCommand(le_sim_Id_t simId)


LE_SIM_COMMAND_MAX
Max value. 
Definition: le_sim_interface.h:614


LE_SIM_STK_EVENT_MAX
Unknown SIM Toolkit event. 
Definition: le_sim_interface.h:631


le_sim_ConnectService
void le_sim_ConnectService(void)


LE_SIM_OPEN_CHANNEL
SIM card ask to open a logical channel. 
Definition: le_sim_interface.h:627


le_sim_GetIMSI
le_result_t le_sim_GetIMSI(le_sim_Id_t simId, char *imsi, size_t imsiSize)


LE_SIM_GEMALTO
Gemalto. 
Definition: le_sim_interface.h:585


LE_SIM_REFRESH
SIM card ask for a refresh. 
Definition: le_sim_interface.h:629


LE_SIM_EXTERNAL_SLOT_1
SIM inserted in external slot 1. 
Definition: le_sim_interface.h:563


le_sim_DisconnectService
void le_sim_DisconnectService(void)


le_sim_NewStateHandlerRef_t
struct le_sim_NewStateHandler * le_sim_NewStateHandlerRef_t
Definition: le_sim_interface.h:642



le_sim_ChangePIN
le_result_t le_sim_ChangePIN(le_sim_Id_t simId, const char *oldpin, const char *newpin)


le_sim_SelectCard
le_result_t le_sim_SelectCard(le_sim_Id_t simId)


le_sim_Manufacturer_t
le_sim_Manufacturer_t
Definition: le_sim_interface.h:581


le_sim_DisconnectHandler_t
void(* le_sim_DisconnectHandler_t)(void *)
Definition: le_sim_interface.h:332


LE_SIM_REMOTE
Remote SIM. 
Definition: le_sim_interface.h:567


LE_SIM_VALID
Valid. 
Definition: le_sim_interface.h:591


le_sim_GetRemainingPINTries
int32_t le_sim_GetRemainingPINTries(le_sim_Id_t simId)


le_sim_IsReady
bool le_sim_IsReady(le_sim_Id_t simId)


le_sim_AddSimToolkitEventHandler
le_sim_SimToolkitEventHandlerRef_t le_sim_AddSimToolkitEventHandler(le_sim_SimToolkitEventHandlerFunc_t handlerPtr, void *contextPtr)


le_sim_RemoveSimToolkitEventHandler
void le_sim_RemoveSimToolkitEventHandler(le_sim_SimToolkitEventHandlerRef_t handlerRef)


le_sim_RemoveNewStateHandler
void le_sim_RemoveNewStateHandler(le_sim_NewStateHandlerRef_t handlerRef)


le_sim_RejectSimToolkitCommand
le_result_t le_sim_RejectSimToolkitCommand(le_sim_Id_t simId)


le_sim_GetSubscriberPhoneNumber
le_result_t le_sim_GetSubscriberPhoneNumber(le_sim_Id_t simId, char *phoneNumberStr, size_t phoneNumberStrSize)


LE_SIM_BLOCKED
SIM card is blocked. 
Definition: le_sim_interface.h:543


le_sim_EnterPIN
le_result_t le_sim_EnterPIN(le_sim_Id_t simId, const char *pin)


le_sim_IsEmergencyCallSubscriptionSelected
le_result_t le_sim_IsEmergencyCallSubscriptionSelected(le_sim_Id_t simId, bool *isEcsPtr)


LE_SIM_G_AND_D
G&D. 
Definition: le_sim_interface.h:587


LE_SIM_MORPHO
Morpho. 
Definition: le_sim_interface.h:589


le_sim_Command_t
le_sim_Command_t
Definition: le_sim_interface.h:604


le_sim_GetSelectedCard
le_sim_Id_t le_sim_GetSelectedCard(void)


le_sim_GetState
le_sim_States_t le_sim_GetState(le_sim_Id_t simId)


le_sim_LocalSwapToCommercialSubscription
le_result_t le_sim_LocalSwapToCommercialSubscription(le_sim_Id_t simId, le_sim_Manufacturer_t manufacturer)


LE_SIM_EXTERNAL_SLOT_2
SIM inserted in external slot 2. 
Definition: le_sim_interface.h:565


le_sim_TryConnectService
le_result_t le_sim_TryConnectService(void)


LE_SIM_STATE_UNKNOWN
Unknown SIM state. 
Definition: le_sim_interface.h:547


LE_SIM_READY
SIM card is inserted and unlocked. 
Definition: le_sim_interface.h:541


LE_SIM_UPDATE_RECORD
Update a file record. 
Definition: le_sim_interface.h:610