The Tor Browser / file revision

 /* Copyright 2012 Mozilla Foundation and Mozilla contributors

  *

  * Licensed under the Apache License, Version 2.0 (the "License");

  * you may not use this file except in compliance with the License.

  * You may obtain a copy of the License at

  *

  *     http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing, software

  * distributed under the License is distributed on an "AS IS" BASIS,

  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  * See the License for the specific language governing permissions and

  * limitations under the License.

  */

 /**

  * This file implements the RIL worker thread. It communicates with

  * the main thread to provide a high-level API to the phone's RIL

  * stack, and with the RIL IPC thread to communicate with the RIL

  * device itself. These communication channels use message events as

  * known from Web Workers:

  *

  * - postMessage()/"message" events for main thread communication

  *

  * - postRILMessage()/"RILMessageEvent" events for RIL IPC thread

  *   communication.

  *

  * The two main objects in this file represent individual parts of this

  * communication chain:

  *

  * - RILMessageEvent -> Buf -> RIL -> postMessage() -> nsIRadioInterfaceLayer

  * - nsIRadioInterfaceLayer -> postMessage() -> RIL -> Buf -> postRILMessage()

  *

  * Note: The code below is purposely lean on abstractions to be as lean in

  * terms of object allocations. As a result, it may look more like C than

  * JavaScript, and that's intended.

  */

 "use strict";

 importScripts("ril_consts.js");

 importScripts("resource://gre/modules/workers/require.js");

 // set to true in ril_consts.js to see debug messages

 let DEBUG = DEBUG_WORKER;

 let GLOBAL = this;

 if (!this.debug) {

   // Debugging stub that goes nowhere.

   this.debug = function debug(message) {

     dump("RIL Worker: " + message + "\n");

   };

 }

 let RIL_CELLBROADCAST_DISABLED;

 let RIL_CLIR_MODE;

 let RIL_EMERGENCY_NUMBERS;

 const DEFAULT_EMERGENCY_NUMBERS = ["112", "911"];

 // Timeout value for emergency callback mode.

 const EMERGENCY_CB_MODE_TIMEOUT_MS = 300000;  // 5 mins = 300000 ms.

 const ICC_MAX_LINEAR_FIXED_RECORDS = 0xfe;

 // MMI match groups

 const MMI_MATCH_GROUP_FULL_MMI = 1;

 const MMI_MATCH_GROUP_MMI_PROCEDURE = 2;

 const MMI_MATCH_GROUP_SERVICE_CODE = 3;

 const MMI_MATCH_GROUP_SIA = 5;

 const MMI_MATCH_GROUP_SIB = 7;

 const MMI_MATCH_GROUP_SIC = 9;

 const MMI_MATCH_GROUP_PWD_CONFIRM = 11;

 const MMI_MATCH_GROUP_DIALING_NUMBER = 12;

 const MMI_MAX_LENGTH_SHORT_CODE = 2;

 const MMI_END_OF_USSD = "#";

 // Should match the value we set in dom/telephony/TelephonyCommon.h

 const OUTGOING_PLACEHOLDER_CALL_INDEX = 0xffffffff;

 let RILQUIRKS_CALLSTATE_EXTRA_UINT32;

 // This may change at runtime since in RIL v6 and later, we get the version

 // number via the UNSOLICITED_RIL_CONNECTED parcel.

 let RILQUIRKS_V5_LEGACY;

 let RILQUIRKS_REQUEST_USE_DIAL_EMERGENCY_CALL;

 let RILQUIRKS_SIM_APP_STATE_EXTRA_FIELDS;

 // Needed for call-waiting on Peak device

 let RILQUIRKS_EXTRA_UINT32_2ND_CALL;

 // On the emulator we support querying the number of lock retries

 let RILQUIRKS_HAVE_QUERY_ICC_LOCK_RETRY_COUNT;

 // Ril quirk to Send STK Profile Download

 let RILQUIRKS_SEND_STK_PROFILE_DOWNLOAD;

 // Ril quirk to attach data registration on demand.

 let RILQUIRKS_DATA_REGISTRATION_ON_DEMAND;

 function BufObject(aContext) {

   this.context = aContext;

 }

 BufObject.prototype = {

   context: null,

   mToken: 0,

   mTokenRequestMap: null,

   init: function() {

     this._init();

     // This gets incremented each time we send out a parcel.

     this.mToken = 1;

     // Maps tokens we send out with requests to the request type, so that

     // when we get a response parcel back, we know what request it was for.

     this.mTokenRequestMap = new Map();

   },

   /**

    * Process one parcel.

    */

   processParcel: function() {

     let response_type = this.readInt32();

     let request_type, options;

     if (response_type == RESPONSE_TYPE_SOLICITED) {

       let token = this.readInt32();

       let error = this.readInt32();

       options = this.mTokenRequestMap.get(token);

       if (!options) {

         if (DEBUG) {

           this.context.debug("Suspicious uninvited request found: " +

                              token + ". Ignored!");

         }

         return;

       }

       this.mTokenRequestMap.delete(token);

       request_type = options.rilRequestType;

       options.rilRequestError = error;

       if (DEBUG) {

         this.context.debug("Solicited response for request type " + request_type +

                            ", token " + token + ", error " + error);

       }

     } else if (response_type == RESPONSE_TYPE_UNSOLICITED) {

       request_type = this.readInt32();

       if (DEBUG) {

         this.context.debug("Unsolicited response for request type " + request_type);

       }

     } else {

       if (DEBUG) {

         this.context.debug("Unknown response type: " + response_type);

       }

       return;

     }

     this.context.RIL.handleParcel(request_type, this.readAvailable, options);

   },

   /**

    * Start a new outgoing parcel.

    *

    * @param type

    *        Integer specifying the request type.

    * @param options [optional]

    *        Object containing information about the request, e.g. the

    *        original main thread message object that led to the RIL request.

    */

   newParcel: function(type, options) {

     if (DEBUG) this.context.debug("New outgoing parcel of type " + type);

     // We're going to leave room for the parcel size at the beginning.

     this.outgoingIndex = this.PARCEL_SIZE_SIZE;

     this.writeInt32(type);

     this.writeInt32(this.mToken);

     if (!options) {

       options = {};

     }

     options.rilRequestType = type;

     options.rilRequestError = null;

     this.mTokenRequestMap.set(this.mToken, options);

     this.mToken++;

     return this.mToken;

   },

   simpleRequest: function(type, options) {

     this.newParcel(type, options);

     this.sendParcel();

   },

   onSendParcel: function(parcel) {

     postRILMessage(this.context.clientId, parcel);

   }

 };

 (function() {

   let base = require("resource://gre/modules/workers/worker_buf.js").Buf;

   for (let p in base) {

     BufObject.prototype[p] = base[p];

   }

 })();

 /**

  * The RIL state machine.

  *

  * This object communicates with rild via parcels and with the main thread

  * via post messages. It maintains state about the radio, ICC, calls, etc.

  * and acts upon state changes accordingly.

  */

 function RilObject(aContext) {

   this.context = aContext;

   this.currentCalls = {};

   this.currentConference = {state: null, participants: {}};

   this.currentDataCalls = {};

   this._pendingSentSmsMap = {};

   this.pendingNetworkType = {};

   this._receivedSmsCbPagesMap = {};

   // Init properties that are only initialized once.

   this.v5Legacy = RILQUIRKS_V5_LEGACY;

   this.cellBroadcastDisabled = RIL_CELLBROADCAST_DISABLED;

   this.clirMode = RIL_CLIR_MODE;

 }

 RilObject.prototype = {

   context: null,

   v5Legacy: null,

   /**

    * Valid calls.

    */

   currentCalls: null,

   /**

    * Existing conference call and its participants.

    */

   currentConference: null,

   /**

    * Existing data calls.

    */

   currentDataCalls: null,

   /**

    * Outgoing messages waiting for SMS-STATUS-REPORT.

    */

   _pendingSentSmsMap: null,

   /**

    * Index of the RIL_PREFERRED_NETWORK_TYPE_TO_GECKO. Its value should be

    * preserved over rild reset.

    */

   preferredNetworkType: null,

   /**

    * Marker object.

    */

   pendingNetworkType: null,

   /**

    * Global Cell Broadcast switch.

    */

   cellBroadcastDisabled: false,

   /**

    * Global CLIR mode settings.

    */

   clirMode: CLIR_DEFAULT,

   /**

    * Parsed Cell Broadcast search lists.

    * cellBroadcastConfigs.MMI should be preserved over rild reset.

    */

   cellBroadcastConfigs: null,

   mergedCellBroadcastConfig: null,

   _receivedSmsCbPagesMap: null,

   initRILState: function() {

     /**

      * One of the RADIO_STATE_* constants.

      */

     this.radioState = GECKO_RADIOSTATE_UNAVAILABLE;

     /**

      * True if we are on a CDMA phone.

      */

     this._isCdma = false;

     /**

      * True if we are in emergency callback mode.

      */

     this._isInEmergencyCbMode = false;

     /**

      * Set when radio is ready but radio tech is unknown. That is, we are

      * waiting for REQUEST_VOICE_RADIO_TECH

      */

     this._waitingRadioTech = false;

     /**

      * ICC status. Keeps a reference of the data response to the

      * getICCStatus request.

      */

     this.iccStatus = null;

     /**

      * Card state

      */

     this.cardState = GECKO_CARDSTATE_UNINITIALIZED;

     /**

      * Strings

      */

     this.IMEI = null;

     this.IMEISV = null;

     this.ESN = null;

     this.MEID = null;

     this.SMSC = null;

     /**

      * ICC information that is not exposed to Gaia.

      */

     this.iccInfoPrivate = {};

     /**

      * ICC information, such as MSISDN, MCC, MNC, SPN...etc.

      */

     this.iccInfo = {};

     /**

      * CDMA specific information. ex. CDMA Network ID, CDMA System ID... etc.

      */

     this.cdmaHome = null;

     /**

      * Application identification for apps in ICC.

      */

     this.aid = null;

     /**

      * Application type for apps in ICC.

      */

     this.appType = null;

     this.networkSelectionMode = null;

     this.voiceRegistrationState = {};

     this.dataRegistrationState = {};

     /**

      * List of strings identifying the network operator.

      */

     this.operator = null;

     /**

      * String containing the baseband version.

      */

     this.basebandVersion = null;

     // Clean up this.currentCalls: rild might have restarted.

     for each (let currentCall in this.currentCalls) {

       delete this.currentCalls[currentCall.callIndex];

       this._handleDisconnectedCall(currentCall);

     }

     // Deactivate this.currentDataCalls: rild might have restarted.

     for each (let datacall in this.currentDataCalls) {

       this.deactivateDataCall(datacall);

     }

     // Don't clean up this._pendingSentSmsMap

     // because on rild restart: we may continue with the pending segments.

     /**

      * Whether or not the multiple requests in requestNetworkInfo() are currently

      * being processed

      */

     this._processingNetworkInfo = false;

     /**

      * Multiple requestNetworkInfo() in a row before finishing the first

      * request, hence we need to fire requestNetworkInfo() again after

      * gathering all necessary stuffs. This is to make sure that ril_worker

      * gets precise network information.

      */

     this._needRepollNetworkInfo = false;

     /**

      * Pending messages to be send in batch from requestNetworkInfo()

      */

     this._pendingNetworkInfo = {rilMessageType: "networkinfochanged"};

     /**

      * USSD session flag.

      * Only one USSD session may exist at a time, and the session is assumed

      * to exist until:

      *    a) There's a call to cancelUSSD()

      *    b) The implementation sends a UNSOLICITED_ON_USSD with a type code

      *       of "0" (USSD-Notify/no further action) or "2" (session terminated)

      */

     this._ussdSession = null;

    /**

     * Regular expresion to parse MMI codes.

     */

     this._mmiRegExp = null;

     /**

      * Cell Broadcast Search Lists.

      */

     let cbmmi = this.cellBroadcastConfigs && this.cellBroadcastConfigs.MMI;

     this.cellBroadcastConfigs = {

       MMI: cbmmi || null

     };

     this.mergedCellBroadcastConfig = null;

   },

   /**

    * Parse an integer from a string, falling back to a default value

    * if the the provided value is not a string or does not contain a valid

    * number.

    *

    * @param string

    *        String to be parsed.

    * @param defaultValue [optional]

    *        Default value to be used.

    * @param radix [optional]

    *        A number that represents the numeral system to be used. Default 10.

    */

   parseInt: function(string, defaultValue, radix) {

     let number = parseInt(string, radix || 10);

     if (!isNaN(number)) {

       return number;

     }

     if (defaultValue === undefined) {

       defaultValue = null;

     }

     return defaultValue;

   },

   /**

    * Outgoing requests to the RIL. These can be triggered from the

    * main thread via messages that look like this:

    *

    *   {rilMessageType: "methodName",

    *    extra:          "parameters",

    *    go:             "here"}

    *

    * So if one of the following methods takes arguments, it takes only one,

    * an object, which then contains all of the parameters as attributes.

    * The "@param" documentation is to be interpreted accordingly.

    */

   /**

    * Retrieve the ICC's status.

    */

   getICCStatus: function() {

     this.context.Buf.simpleRequest(REQUEST_GET_SIM_STATUS);

   },

   /**

    * Helper function for unlocking ICC locks.

    */

   iccUnlockCardLock: function(options) {

     switch (options.lockType) {

       case GECKO_CARDLOCK_PIN:

         this.enterICCPIN(options);

         break;

       case GECKO_CARDLOCK_PIN2:

         this.enterICCPIN2(options);

         break;

       case GECKO_CARDLOCK_PUK:

         this.enterICCPUK(options);

         break;

       case GECKO_CARDLOCK_PUK2:

         this.enterICCPUK2(options);

         break;

       case GECKO_CARDLOCK_NCK:

       case GECKO_CARDLOCK_NCK1:

       case GECKO_CARDLOCK_NCK2:

       case GECKO_CARDLOCK_HNCK:

       case GECKO_CARDLOCK_CCK:

       case GECKO_CARDLOCK_SPCK:

       case GECKO_CARDLOCK_RCCK: // Fall through.

       case GECKO_CARDLOCK_RSPCK: {

         let type = GECKO_PERSO_LOCK_TO_CARD_PERSO_LOCK[options.lockType];

         this.enterDepersonalization(type, options.pin, options);

         break;

       }

       case GECKO_CARDLOCK_NCK_PUK:

       case GECKO_CARDLOCK_NCK1_PUK:

       case GECKO_CARDLOCK_NCK2_PUK:

       case GECKO_CARDLOCK_HNCK_PUK:

       case GECKO_CARDLOCK_CCK_PUK:

       case GECKO_CARDLOCK_SPCK_PUK:

       case GECKO_CARDLOCK_RCCK_PUK: // Fall through.

       case GECKO_CARDLOCK_RSPCK_PUK: {

         let type = GECKO_PERSO_LOCK_TO_CARD_PERSO_LOCK[options.lockType];

         this.enterDepersonalization(type, options.puk, options);

         break;

       }

       default:

         options.errorMsg = "Unsupported Card Lock.";

         options.success = false;

         this.sendChromeMessage(options);

     }

   },

   /**

    * Enter a PIN to unlock the ICC.

    *

    * @param pin

    *        String containing the PIN.

    * @param [optional] aid

    *        AID value.

    */

   enterICCPIN: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_ENTER_SIM_PIN, options);

     Buf.writeInt32(this.v5Legacy ? 1 : 2);

     Buf.writeString(options.pin);

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Enter a PIN2 to unlock the ICC.

    *

    * @param pin

    *        String containing the PIN2.

    * @param [optional] aid

    *        AID value.

    */

   enterICCPIN2: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_ENTER_SIM_PIN2, options);

     Buf.writeInt32(this.v5Legacy ? 1 : 2);

     Buf.writeString(options.pin);

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Requests a network personalization be deactivated.

    *

    * @param type

    *        Integer indicating the network personalization be deactivated.

    * @param password

    *        String containing the password.

    */

   enterDepersonalization: function(type, password, options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_ENTER_NETWORK_DEPERSONALIZATION_CODE, options);

     Buf.writeInt32(type);

     Buf.writeString(password);

     Buf.sendParcel();

   },

   /**

    * Helper function for changing ICC locks.

    */

   iccSetCardLock: function(options) {

     if (options.newPin !== undefined) { // Change PIN lock.

       switch (options.lockType) {

         case GECKO_CARDLOCK_PIN:

           this.changeICCPIN(options);

           break;

         case GECKO_CARDLOCK_PIN2:

           this.changeICCPIN2(options);

           break;

         default:

           options.errorMsg = "Unsupported Card Lock.";

           options.success = false;

           this.sendChromeMessage(options);

       }

     } else { // Enable/Disable lock.

       switch (options.lockType) {

         case GECKO_CARDLOCK_PIN:

           options.facility = ICC_CB_FACILITY_SIM;

           options.password = options.pin;

           break;

         case GECKO_CARDLOCK_FDN:

           options.facility = ICC_CB_FACILITY_FDN;

           options.password = options.pin2;

           break;

         default:

           options.errorMsg = "Unsupported Card Lock.";

           options.success = false;

           this.sendChromeMessage(options);

           return;

       }

       options.enabled = options.enabled;

       options.serviceClass = ICC_SERVICE_CLASS_VOICE |

                              ICC_SERVICE_CLASS_DATA  |

                              ICC_SERVICE_CLASS_FAX;

       this.setICCFacilityLock(options);

     }

   },

   /**

    * Change the current ICC PIN number.

    *

    * @param pin

    *        String containing the old PIN value

    * @param newPin

    *        String containing the new PIN value

    * @param [optional] aid

    *        AID value.

    */

   changeICCPIN: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_CHANGE_SIM_PIN, options);

     Buf.writeInt32(this.v5Legacy ? 2 : 3);

     Buf.writeString(options.pin);

     Buf.writeString(options.newPin);

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Change the current ICC PIN2 number.

    *

    * @param pin

    *        String containing the old PIN2 value

    * @param newPin

    *        String containing the new PIN2 value

    * @param [optional] aid

    *        AID value.

    */

   changeICCPIN2: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_CHANGE_SIM_PIN2, options);

     Buf.writeInt32(this.v5Legacy ? 2 : 3);

     Buf.writeString(options.pin);

     Buf.writeString(options.newPin);

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Supplies ICC PUK and a new PIN to unlock the ICC.

    *

    * @param puk

    *        String containing the PUK value.

    * @param newPin

    *        String containing the new PIN value.

    * @param [optional] aid

    *        AID value.

    */

    enterICCPUK: function(options) {

      let Buf = this.context.Buf;

      Buf.newParcel(REQUEST_ENTER_SIM_PUK, options);

      Buf.writeInt32(this.v5Legacy ? 2 : 3);

      Buf.writeString(options.puk);

      Buf.writeString(options.newPin);

      if (!this.v5Legacy) {

        Buf.writeString(options.aid || this.aid);

      }

      Buf.sendParcel();

    },

   /**

    * Supplies ICC PUK2 and a new PIN2 to unlock the ICC.

    *

    * @param puk

    *        String containing the PUK2 value.

    * @param newPin

    *        String containing the new PIN2 value.

    * @param [optional] aid

    *        AID value.

    */

    enterICCPUK2: function(options) {

      let Buf = this.context.Buf;

      Buf.newParcel(REQUEST_ENTER_SIM_PUK2, options);

      Buf.writeInt32(this.v5Legacy ? 2 : 3);

      Buf.writeString(options.puk);

      Buf.writeString(options.newPin);

      if (!this.v5Legacy) {

        Buf.writeString(options.aid || this.aid);

      }

      Buf.sendParcel();

    },

   /**

    * Helper function for fetching the state of ICC locks.

    */

   iccGetCardLockState: function(options) {

     switch (options.lockType) {

       case GECKO_CARDLOCK_PIN:

         options.facility = ICC_CB_FACILITY_SIM;

         break;

       case GECKO_CARDLOCK_FDN:

         options.facility = ICC_CB_FACILITY_FDN;

         break;

       default:

         options.errorMsg = "Unsupported Card Lock.";

         options.success = false;

         this.sendChromeMessage(options);

         return;

     }

     options.password = ""; // For query no need to provide pin.

     options.serviceClass = ICC_SERVICE_CLASS_VOICE |

                            ICC_SERVICE_CLASS_DATA  |

                            ICC_SERVICE_CLASS_FAX;

     this.queryICCFacilityLock(options);

   },

   /**

    * Helper function for fetching the number of unlock retries of ICC locks.

    *

    * We only query the retry count when we're on the emulator. The phones do

    * not support the request id and their rild doesn't return an error.

    */

   iccGetCardLockRetryCount: function(options) {

     var selCode = {

       pin: ICC_SEL_CODE_SIM_PIN,

       puk: ICC_SEL_CODE_SIM_PUK,

       pin2: ICC_SEL_CODE_SIM_PIN2,

       puk2: ICC_SEL_CODE_SIM_PUK2,

       nck: ICC_SEL_CODE_PH_NET_PIN,

       cck: ICC_SEL_CODE_PH_CORP_PIN,

       spck: ICC_SEL_CODE_PH_SP_PIN

     };

     if (typeof(selCode[options.lockType]) === 'undefined') {

       /* unknown lock type */

       options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;

       options.success = false;

       this.sendChromeMessage(options);

       return;

     }

     if (RILQUIRKS_HAVE_QUERY_ICC_LOCK_RETRY_COUNT) {

       /* Only the emulator supports this request, ... */

       options.selCode = selCode[options.lockType];

       this.queryICCLockRetryCount(options);

     } else {

       /* ... while the phones do not. */

       options.errorMsg = GECKO_ERROR_REQUEST_NOT_SUPPORTED;

       options.success = false;

       this.sendChromeMessage(options);

     }

   },

   /**

    * Query ICC lock retry count.

    *

    * @param selCode

    *        One of ICC_SEL_CODE_*.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_*.

    */

   queryICCLockRetryCount: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_GET_UNLOCK_RETRY_COUNT, options);

     Buf.writeInt32(1);

     Buf.writeString(options.selCode);

     Buf.sendParcel();

   },

   /**

    * Query ICC facility lock.

    *

    * @param facility

    *        One of ICC_CB_FACILITY_*.

    * @param password

    *        Password for the facility, or "" if not required.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_*.

    * @param [optional] aid

    *        AID value.

    */

   queryICCFacilityLock: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_QUERY_FACILITY_LOCK, options);

     Buf.writeInt32(this.v5Legacy ? 3 : 4);

     Buf.writeString(options.facility);

     Buf.writeString(options.password);

     Buf.writeString(options.serviceClass.toString());

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Set ICC facility lock.

    *

    * @param facility

    *        One of ICC_CB_FACILITY_*.

    * @param enabled

    *        true to enable, false to disable.

    * @param password

    *        Password for the facility, or "" if not required.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_*.

    * @param [optional] aid

    *        AID value.

    */

   setICCFacilityLock: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_FACILITY_LOCK, options);

     Buf.writeInt32(this.v5Legacy ? 4 : 5);

     Buf.writeString(options.facility);

     Buf.writeString(options.enabled ? "1" : "0");

     Buf.writeString(options.password);

     Buf.writeString(options.serviceClass.toString());

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    *  Request an ICC I/O operation.

    *

    *  See TS 27.007 "restricted SIM" operation, "AT Command +CRSM".

    *  The sequence is in the same order as how libril reads this parcel,

    *  see the struct RIL_SIM_IO_v5 or RIL_SIM_IO_v6 defined in ril.h

    *

    *  @param command

    *         The I/O command, one of the ICC_COMMAND_* constants.

    *  @param fileId

    *         The file to operate on, one of the ICC_EF_* constants.

    *  @param pathId

    *         String type, check the 'pathid' parameter from TS 27.007 +CRSM.

    *  @param p1, p2, p3

    *         Arbitrary integer parameters for the command.

    *  @param [optional] dataWriter

    *         The function for writing string parameter for the ICC_COMMAND_UPDATE_RECORD.

    *  @param [optional] pin2

    *         String containing the PIN2.

    *  @param [optional] aid

    *         AID value.

    */

   iccIO: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SIM_IO, options);

     Buf.writeInt32(options.command);

     Buf.writeInt32(options.fileId);

     Buf.writeString(options.pathId);

     Buf.writeInt32(options.p1);

     Buf.writeInt32(options.p2);

     Buf.writeInt32(options.p3);

     // Write data.

     if (options.command == ICC_COMMAND_UPDATE_RECORD &&

         options.dataWriter) {

       options.dataWriter(options.p3);

     } else {

       Buf.writeString(null);

     }

     // Write pin2.

     if (options.command == ICC_COMMAND_UPDATE_RECORD &&

         options.pin2) {

       Buf.writeString(options.pin2);

     } else {

       Buf.writeString(null);

     }

     if (!this.v5Legacy) {

       Buf.writeString(options.aid || this.aid);

     }

     Buf.sendParcel();

   },

   /**

    * Get IMSI.

    *

    * @param [optional] aid

    *        AID value.

    */

   getIMSI: function(aid) {

     let Buf = this.context.Buf;

     if (this.v5Legacy) {

       Buf.simpleRequest(REQUEST_GET_IMSI);

       return;

     }

     Buf.newParcel(REQUEST_GET_IMSI);

     Buf.writeInt32(1);

     Buf.writeString(aid || this.aid);

     Buf.sendParcel();

   },

   /**

    * Read UICC Phonebook contacts.

    *

    * @param contactType

    *        "adn" or "fdn".

    * @param requestId

    *        Request id from RadioInterfaceLayer.

    */

   readICCContacts: function(options) {

     if (!this.appType) {

       options.errorMsg = CONTACT_ERR_REQUEST_NOT_SUPPORTED;

       this.sendChromeMessage(options);

       return;

     }

     this.context.ICCContactHelper.readICCContacts(

       this.appType,

       options.contactType,

       function onsuccess(contacts) {

         for (let i = 0; i < contacts.length; i++) {

           let contact = contacts[i];

           let pbrIndex = contact.pbrIndex || 0;

           let recordIndex = pbrIndex * ICC_MAX_LINEAR_FIXED_RECORDS + contact.recordId;

           contact.contactId = this.iccInfo.iccid + recordIndex;

         }

         // Reuse 'options' to get 'requestId' and 'contactType'.

         options.contacts = contacts;

         this.sendChromeMessage(options);

       }.bind(this),

       function onerror(errorMsg) {

         options.errorMsg = errorMsg;

         this.sendChromeMessage(options);

       }.bind(this));

   },

   /**

    * Update UICC Phonebook.

    *

    * @param contactType   "adn" or "fdn".

    * @param contact       The contact will be updated.

    * @param pin2          PIN2 is required for updating FDN.

    * @param requestId     Request id from RadioInterfaceLayer.

    */

   updateICCContact: function(options) {

     let onsuccess = function onsuccess() {

       let recordIndex =

         contact.pbrIndex * ICC_MAX_LINEAR_FIXED_RECORDS + contact.recordId;

       contact.contactId = this.iccInfo.iccid + recordIndex;

       // Reuse 'options' to get 'requestId' and 'contactType'.

       this.sendChromeMessage(options);

     }.bind(this);

     let onerror = function onerror(errorMsg) {

       options.errorMsg = errorMsg;

       this.sendChromeMessage(options);

     }.bind(this);

     if (!this.appType || !options.contact) {

       onerror(CONTACT_ERR_REQUEST_NOT_SUPPORTED );

       return;

     }

     let contact = options.contact;

     let iccid = this.iccInfo.iccid;

     let isValidRecordId = false;

     if (typeof contact.contactId === "string" &&

         contact.contactId.startsWith(iccid)) {

       let recordIndex = contact.contactId.substring(iccid.length);

       contact.pbrIndex = Math.floor(recordIndex / ICC_MAX_LINEAR_FIXED_RECORDS);

       contact.recordId = recordIndex % ICC_MAX_LINEAR_FIXED_RECORDS;

       isValidRecordId = contact.recordId > 0 && contact.recordId < 0xff;

     }

     if (DEBUG) {

       this.context.debug("Update ICC Contact " + JSON.stringify(contact));

     }

     let ICCContactHelper = this.context.ICCContactHelper;

     // If contact has 'recordId' property, updates corresponding record.

     // If not, inserts the contact into a free record.

     if (isValidRecordId) {

       ICCContactHelper.updateICCContact(

         this.appType, options.contactType, contact, options.pin2, onsuccess, onerror);

     } else {

       ICCContactHelper.addICCContact(

         this.appType, options.contactType, contact, options.pin2, onsuccess, onerror);

     }

   },

   /**

    * Request the phone's radio to be enabled or disabled.

    *

    * @param enabled

    *        Boolean indicating the desired state.

    */

   setRadioEnabled: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_RADIO_POWER, options);

     Buf.writeInt32(1);

     Buf.writeInt32(options.enabled ? 1 : 0);

     Buf.sendParcel();

   },

   /**

    * Query call waiting status via MMI.

    */

   _handleQueryMMICallWaiting: function(options) {

     let Buf = this.context.Buf;

     function callback(options) {

       options.length = Buf.readInt32();

       options.enabled = (Buf.readInt32() === 1);

       let services = Buf.readInt32();

       if (options.enabled) {

         options.statusMessage = MMI_SM_KS_SERVICE_ENABLED_FOR;

         let serviceClass = [];

         for (let serviceClassMask = 1;

              serviceClassMask <= ICC_SERVICE_CLASS_MAX;

              serviceClassMask <<= 1) {

           if ((serviceClassMask & services) !== 0) {

             serviceClass.push(MMI_KS_SERVICE_CLASS_MAPPING[serviceClassMask]);

           }

         }

         options.additionalInformation = serviceClass;

       } else {

         options.statusMessage = MMI_SM_KS_SERVICE_DISABLED;

       }

       // Prevent DataCloneError when sending chrome messages.

       delete options.callback;

       this.sendChromeMessage(options);

     }

     options.callback = callback;

     this.queryCallWaiting(options);

   },

   /**

    * Set call waiting status via MMI.

    */

   _handleSetMMICallWaiting: function(options) {

     function callback(options) {

       if (options.enabled) {

         options.statusMessage = MMI_SM_KS_SERVICE_ENABLED;

       } else {

         options.statusMessage = MMI_SM_KS_SERVICE_DISABLED;

       }

       // Prevent DataCloneError when sending chrome messages.

       delete options.callback;

       this.sendChromeMessage(options);

     }

     options.callback = callback;

     this.setCallWaiting(options);

   },

   /**

    * Query call waiting status.

    *

    */

   queryCallWaiting: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_QUERY_CALL_WAITING, options);

     Buf.writeInt32(1);

     // As per 3GPP TS 24.083, section 1.6 UE doesn't need to send service

     // class parameter in call waiting interrogation  to network

     Buf.writeInt32(ICC_SERVICE_CLASS_NONE);

     Buf.sendParcel();

   },

   /**

    * Set call waiting status.

    *

    * @param on

    *        Boolean indicating the desired waiting status.

    */

   setCallWaiting: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_CALL_WAITING, options);

     Buf.writeInt32(2);

     Buf.writeInt32(options.enabled ? 1 : 0);

     Buf.writeInt32(options.serviceClass !== undefined ?

                     options.serviceClass : ICC_SERVICE_CLASS_VOICE);

     Buf.sendParcel();

   },

   /**

    * Queries current CLIP status.

    *

    * (MMI request for code "*#30#")

    *

    */

   queryCLIP: function(options) {

     this.context.Buf.simpleRequest(REQUEST_QUERY_CLIP, options);

   },

   /**

    * Queries current CLIR status.

    *

    */

   getCLIR: function(options) {

     this.context.Buf.simpleRequest(REQUEST_GET_CLIR, options);

   },

   /**

    * Enables or disables the presentation of the calling line identity (CLI) to

    * the called party when originating a call.

    *

    * @param options.clirMode

    *        Is one of the CLIR_* constants in

    *        nsIDOMMozMobileConnection interface.

    */

   setCLIR: function(options) {

     if (options) {

       this.clirMode = options.clirMode;

     }

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_CLIR, options);

     Buf.writeInt32(1);

     Buf.writeInt32(this.clirMode);

     Buf.sendParcel();

   },

   /**

    * Set screen state.

    *

    * @param on

    *        Boolean indicating whether the screen should be on or off.

    */

   setScreenState: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SCREEN_STATE);

     Buf.writeInt32(1);

     Buf.writeInt32(options.on ? 1 : 0);

     Buf.sendParcel();

   },

   getVoiceRegistrationState: function() {

     this.context.Buf.simpleRequest(REQUEST_VOICE_REGISTRATION_STATE);

   },

   getVoiceRadioTechnology: function() {

     this.context.Buf.simpleRequest(REQUEST_VOICE_RADIO_TECH);

   },

   getDataRegistrationState: function() {

     this.context.Buf.simpleRequest(REQUEST_DATA_REGISTRATION_STATE);

   },

   getOperator: function() {

     this.context.Buf.simpleRequest(REQUEST_OPERATOR);

   },

   /**

    * Set the preferred network type.

    *

    * @param options An object contains a valid index of

    *                RIL_PREFERRED_NETWORK_TYPE_TO_GECKO as its `networkType`

    *                attribute, or undefined to set current preferred network

    *                type.

    */

   setPreferredNetworkType: function(options) {

     if (options) {

       this.preferredNetworkType = options.networkType;

     }

     if (this.preferredNetworkType == null) {

       return;

     }

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_PREFERRED_NETWORK_TYPE, options);

     Buf.writeInt32(1);

     Buf.writeInt32(this.preferredNetworkType);

     Buf.sendParcel();

   },

   /**

    * Get the preferred network type.

    */

   getPreferredNetworkType: function(options) {

     this.context.Buf.simpleRequest(REQUEST_GET_PREFERRED_NETWORK_TYPE, options);

   },

   /**

    * Request various states about the network.

    */

   requestNetworkInfo: function() {

     if (this._processingNetworkInfo) {

       if (DEBUG) {

         this.context.debug("Network info requested, but we're already " +

                            "requesting network info.");

       }

       this._needRepollNetworkInfo = true;

       return;

     }

     if (DEBUG) this.context.debug("Requesting network info");

     this._processingNetworkInfo = true;

     this.getVoiceRegistrationState();

     this.getDataRegistrationState(); //TODO only GSM

     this.getOperator();

     this.getNetworkSelectionMode();

     this.getSignalStrength();

   },

   /**

    * Get the available networks

    */

   getAvailableNetworks: function(options) {

     if (DEBUG) this.context.debug("Getting available networks");

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_QUERY_AVAILABLE_NETWORKS, options);

     Buf.sendParcel();

   },

   /**

    * Request the radio's network selection mode

    */

   getNetworkSelectionMode: function() {

     if (DEBUG) this.context.debug("Getting network selection mode");

     this.context.Buf.simpleRequest(REQUEST_QUERY_NETWORK_SELECTION_MODE);

   },

   /**

    * Tell the radio to automatically choose a voice/data network

    */

   selectNetworkAuto: function(options) {

     if (DEBUG) this.context.debug("Setting automatic network selection");

     this.context.Buf.simpleRequest(REQUEST_SET_NETWORK_SELECTION_AUTOMATIC, options);

   },

   /**

    * Set the roaming preference mode

    */

   setRoamingPreference: function(options) {

     let roamingMode = CDMA_ROAMING_PREFERENCE_TO_GECKO.indexOf(options.mode);

     if (roamingMode === -1) {

       options.errorMsg = GECKO_ERROR_INVALID_PARAMETER;

       this.sendChromeMessage(options);

       return;

     }

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_CDMA_SET_ROAMING_PREFERENCE, options);

     Buf.writeInt32(1);

     Buf.writeInt32(roamingMode);

     Buf.sendParcel();

   },

   /**

    * Get the roaming preference mode

    */

   queryRoamingPreference: function(options) {

     this.context.Buf.simpleRequest(REQUEST_CDMA_QUERY_ROAMING_PREFERENCE, options);

   },

   /**

    * Set the voice privacy mode

    */

   setVoicePrivacyMode: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_CDMA_SET_PREFERRED_VOICE_PRIVACY_MODE, options);

     Buf.writeInt32(1);

     Buf.writeInt32(options.enabled ? 1 : 0);

     Buf.sendParcel();

   },

   /**

    * Get the voice privacy mode

    */

   queryVoicePrivacyMode: function(options) {

     this.context.Buf.simpleRequest(REQUEST_CDMA_QUERY_PREFERRED_VOICE_PRIVACY_MODE, options);

   },

   /**

    * Open Logical UICC channel (aid) for Secure Element access

    */

   iccOpenChannel: function(options) {

     if (DEBUG) {

       this.context.debug("iccOpenChannel: " + JSON.stringify(options));

     }

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SIM_OPEN_CHANNEL, options);

     Buf.writeString(options.aid);

     Buf.sendParcel();

   },

 /**

    * Exchange APDU data on an open Logical UICC channel

    */

   iccExchangeAPDU: function(options) {

     if (DEBUG) this.context.debug("iccExchangeAPDU: " + JSON.stringify(options));

     let cla = options.apdu.cla;

     let command = options.apdu.command;

     let channel = options.channel;

     let path = options.apdu.path || "";

     let data = options.apdu.data || "";

     let data2 = options.apdu.data2 || "";

     let p1 = options.apdu.p1;

     let p2 = options.apdu.p2;

     let p3 = options.apdu.p3; // Extra

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SIM_ACCESS_CHANNEL, options);

     Buf.writeInt32(cla);

     Buf.writeInt32(command);

     Buf.writeInt32(channel);

     Buf.writeString(path); // path

     Buf.writeInt32(p1);

     Buf.writeInt32(p2);

     Buf.writeInt32(p3);

     Buf.writeString(data); // generic data field.

     Buf.writeString(data2);

     Buf.sendParcel();

   },

   /**

    * Close Logical UICC channel

    */

   iccCloseChannel: function(options) {

     if (DEBUG) this.context.debug("iccCloseChannel: " + JSON.stringify(options));

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SIM_CLOSE_CHANNEL, options);

     Buf.writeInt32(1);

     Buf.writeInt32(options.channel);

     Buf.sendParcel();

   },

   /**

    * Tell the radio to choose a specific voice/data network

    */

   selectNetwork: function(options) {

     if (DEBUG) {

       this.context.debug("Setting manual network selection: " +

                          options.mcc + ", " + options.mnc);

     }

     let numeric = (options.mcc && options.mnc) ? options.mcc + options.mnc : null;

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_NETWORK_SELECTION_MANUAL, options);

     Buf.writeString(numeric);

     Buf.sendParcel();

   },

   /**

    * Get current calls.

    */

   getCurrentCalls: function() {

     this.context.Buf.simpleRequest(REQUEST_GET_CURRENT_CALLS);

   },

   /**

    * Get the signal strength.

    */

   getSignalStrength: function() {

     this.context.Buf.simpleRequest(REQUEST_SIGNAL_STRENGTH);

   },

   getIMEI: function(options) {

     this.context.Buf.simpleRequest(REQUEST_GET_IMEI, options);

   },

   getIMEISV: function() {

     this.context.Buf.simpleRequest(REQUEST_GET_IMEISV);

   },

   getDeviceIdentity: function() {

     this.context.Buf.simpleRequest(REQUEST_DEVICE_IDENTITY);

   },

   getBasebandVersion: function() {

     this.context.Buf.simpleRequest(REQUEST_BASEBAND_VERSION);

   },

   sendExitEmergencyCbModeRequest: function(options) {

     this.context.Buf.simpleRequest(REQUEST_EXIT_EMERGENCY_CALLBACK_MODE, options);

   },

   getCdmaSubscription: function() {

     this.context.Buf.simpleRequest(REQUEST_CDMA_SUBSCRIPTION);

   },

   exitEmergencyCbMode: function(options) {

     // The function could be called by an API from RadioInterfaceLayer or by

     // ril_worker itself. From ril_worker, we won't pass the parameter

     // 'options'. In this case, it is marked as internal.

     if (!options) {

       options = {internal: true};

     }

     this._cancelEmergencyCbModeTimeout();

     this.sendExitEmergencyCbModeRequest(options);

   },

   /**

    * Cache the request for making an emergency call when radio is off. The

    * request shall include two types of callback functions. 'callback' is

    * called when radio is ready, and 'onerror' is called when turning radio

    * on fails.

    */

   cachedDialRequest : null,

   /**

    * Dial the phone.

    *

    * @param number

    *        String containing the number to dial.

    * @param clirMode

    *        Integer for showing/hidding the caller Id to the called party.

    * @param uusInfo

    *        Integer doing something XXX TODO

    */

   dial: function(options) {

     let onerror = (function onerror(options, errorMsg) {

       options.success = false;

       options.errorMsg = errorMsg;

       this.sendChromeMessage(options);

     }).bind(this, options);

     if (this._isEmergencyNumber(options.number)) {

       this.dialEmergencyNumber(options, onerror);

     } else {

       if (!this._isCdma) {

         // TODO: Both dial() and sendMMI() functions should be unified at some

         // point in the future. In the mean time we handle temporary CLIR MMI

         // commands through the dial() function. Please see bug 889737.

         let mmi = this._parseMMI(options.number);

         if (mmi && this._isTemporaryModeCLIR(mmi)) {

           options.number = mmi.dialNumber;

           // In temporary mode, MMI_PROCEDURE_ACTIVATION means allowing CLI

           // presentation, i.e. CLIR_SUPPRESSION. See TS 22.030, Annex B.

           options.clirMode = mmi.procedure == MMI_PROCEDURE_ACTIVATION ?

                              CLIR_SUPPRESSION : CLIR_INVOCATION;

         }

       }

       this.dialNonEmergencyNumber(options, onerror);

     }

   },

   dialNonEmergencyNumber: function(options, onerror) {

     if (this.radioState == GECKO_RADIOSTATE_OFF) {

       // Notify error in establishing the call without radio.

       onerror(GECKO_ERROR_RADIO_NOT_AVAILABLE);

       return;

     }

     if (this.voiceRegistrationState.emergencyCallsOnly ||

         options.isDialEmergency) {

       onerror(RIL_CALL_FAILCAUSE_TO_GECKO_CALL_ERROR[CALL_FAIL_UNOBTAINABLE_NUMBER]);

       return;

     }

     // Exit emergency callback mode when user dial a non-emergency call.

     if (this._isInEmergencyCbMode) {

       this.exitEmergencyCbMode();

     }

     if (this._isCdma && Object.keys(this.currentCalls).length == 1) {

       // Make a Cdma 3way call.

       options.featureStr = options.number;

       this.sendCdmaFlashCommand(options);

     } else {

       options.request = REQUEST_DIAL;

       this.sendDialRequest(options);

     }

   },

   dialEmergencyNumber: function(options, onerror) {

     options.request = RILQUIRKS_REQUEST_USE_DIAL_EMERGENCY_CALL ?

                       REQUEST_DIAL_EMERGENCY_CALL : REQUEST_DIAL;

     if (this.radioState == GECKO_RADIOSTATE_OFF) {

       if (DEBUG) {

         this.context.debug("Automatically enable radio for an emergency call.");

       }

       if (!this.cachedDialRequest) {

         this.cachedDialRequest = {};

       }

       this.cachedDialRequest.onerror = onerror;

       this.cachedDialRequest.callback = this.sendDialRequest.bind(this, options);

       this.setRadioEnabled({enabled: true});

       return;

     }

     if (this._isCdma && Object.keys(this.currentCalls).length == 1) {

       // Make a Cdma 3way call.

       options.featureStr = options.number;

       this.sendCdmaFlashCommand(options);

     } else {

       this.sendDialRequest(options);

     }

   },

   sendDialRequest: function(options) {

     // Always succeed.

     options.success = true;

     this.sendChromeMessage(options);

     this._createPendingOutgoingCall(options);

     let Buf = this.context.Buf;

     Buf.newParcel(options.request, options);

     Buf.writeString(options.number);

     Buf.writeInt32(options.clirMode || 0);

     Buf.writeInt32(options.uusInfo || 0);

     // TODO Why do we need this extra 0? It was put it in to make this

     // match the format of the binary message.

     Buf.writeInt32(0);

     Buf.sendParcel();

   },

   sendCdmaFlashCommand: function(options) {

     let Buf = this.context.Buf;

     options.isCdma = true;

     options.request = REQUEST_CDMA_FLASH;

     Buf.newParcel(options.request, options);

     Buf.writeString(options.featureStr);

     Buf.sendParcel();

   },

   /**

    * Hang up all calls

    */

   hangUpAll: function() {

     for (let callIndex in this.currentCalls) {

       this.hangUp({callIndex: callIndex});

     }

   },

   /**

    * Hang up the phone.

    *

    * @param callIndex

    *        Call index (1-based) as reported by REQUEST_GET_CURRENT_CALLS.

    */

   hangUp: function(options) {

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       return;

     }

     let callIndex = call.callIndex;

     if (callIndex === OUTGOING_PLACEHOLDER_CALL_INDEX) {

       if (DEBUG) this.context.debug("Hang up pending outgoing call.");

       this._removeVoiceCall(call, GECKO_CALL_ERROR_NORMAL_CALL_CLEARING);

       return;

     }

     call.hangUpLocal = true;

     if (call.state === CALL_STATE_HOLDING) {

       this.sendHangUpBackgroundRequest(callIndex);

     } else {

       this.sendHangUpRequest(callIndex);

     }

   },

   sendHangUpRequest: function(callIndex) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_HANGUP);

     Buf.writeInt32(1);

     Buf.writeInt32(callIndex);

     Buf.sendParcel();

   },

   sendHangUpBackgroundRequest: function(callIndex) {

     let Buf = this.context.Buf;

     Buf.simpleRequest(REQUEST_HANGUP_WAITING_OR_BACKGROUND);

   },

   /**

    * Mute or unmute the radio.

    *

    * @param mute

    *        Boolean to indicate whether to mute or unmute the radio.

    */

   setMute: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_MUTE);

     Buf.writeInt32(1);

     Buf.writeInt32(options.muted ? 1 : 0);

     Buf.sendParcel();

   },

   /**

    * Answer an incoming/waiting call.

    *

    * @param callIndex

    *        Call index of the call to answer.

    */

   answerCall: function(options) {

     // Check for races. Since we dispatched the incoming/waiting call

     // notification the incoming/waiting call may have changed. The main

     // thread thinks that it is answering the call with the given index,

     // so only answer if that is still incoming/waiting.

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       return;

     }

     let Buf = this.context.Buf;

     switch (call.state) {

       case CALL_STATE_INCOMING:

         Buf.simpleRequest(REQUEST_ANSWER);

         break;

       case CALL_STATE_WAITING:

         // Answer the waiting (second) call, and hold the first call.

         Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);

         break;

     }

   },

   /**

    * Reject an incoming/waiting call.

    *

    * @param callIndex

    *        Call index of the call to reject.

    */

   rejectCall: function(options) {

     // Check for races. Since we dispatched the incoming/waiting call

     // notification the incoming/waiting call may have changed. The main

     // thread thinks that it is rejecting the call with the given index,

     // so only reject if that is still incoming/waiting.

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       return;

     }

     call.hangUpLocal = true;

     let Buf = this.context.Buf;

     if (this._isCdma) {

       // AT+CHLD=0 means "release held or UDUB."

       Buf.simpleRequest(REQUEST_HANGUP_WAITING_OR_BACKGROUND);

       return;

     }

     switch (call.state) {

       case CALL_STATE_INCOMING:

         Buf.simpleRequest(REQUEST_UDUB);

         break;

       case CALL_STATE_WAITING:

         // Reject the waiting (second) call, and remain the first call.

         Buf.simpleRequest(REQUEST_HANGUP_WAITING_OR_BACKGROUND);

         break;

     }

   },

   holdCall: function(options) {

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;

       options.success = false;

       this.sendChromeMessage(options);

       return;

     }

     let Buf = this.context.Buf;

     if (this._isCdma) {

       options.featureStr = "";

       this.sendCdmaFlashCommand(options);

     } else if (call.state == CALL_STATE_ACTIVE) {

       Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, options);

     }

  },

   resumeCall: function(options) {

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;

       options.success = false;

       this.sendChromeMessage(options);

       return;

     }

     let Buf = this.context.Buf;

     if (this._isCdma) {

       options.featureStr = "";

       this.sendCdmaFlashCommand(options);

     } else if (call.state == CALL_STATE_HOLDING) {

       Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE, options);

     }

   },

   // Flag indicating whether user has requested making a conference call.

   _hasConferenceRequest: false,

   conferenceCall: function(options) {

     let Buf = this.context.Buf;

     if (this._isCdma) {

       options.featureStr = "";

       this.sendCdmaFlashCommand(options);

     } else {

       this._hasConferenceRequest = true;

       Buf.simpleRequest(REQUEST_CONFERENCE, options);

     }

   },

   separateCall: function(options) {

     let call = this.currentCalls[options.callIndex];

     if (!call) {

       options.errorName = "removeError";

       options.errorMsg = GECKO_ERROR_GENERIC_FAILURE;

       options.success = false;

       this.sendChromeMessage(options);

       return;

     }

     let Buf = this.context.Buf;

     if (this._isCdma) {

       options.featureStr = "";

       this.sendCdmaFlashCommand(options);

     } else {

       Buf.newParcel(REQUEST_SEPARATE_CONNECTION, options);

       Buf.writeInt32(1);

       Buf.writeInt32(options.callIndex);

       Buf.sendParcel();

     }

  },

   holdConference: function() {

     if (this._isCdma) {

       return;

     }

     this.context.Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);

   },

   resumeConference: function() {

     if (this._isCdma) {

       return;

     }

     this.context.Buf.simpleRequest(REQUEST_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE);

   },

   /**

    * Send an SMS.

    *

    * The `options` parameter object should contain the following attributes:

    *

    * @param number

    *        String containing the recipient number.

    * @param body

    *        String containing the message text.

    * @param envelopeId

    *        Numeric value identifying the sms request.

    */

   sendSMS: function(options) {

     options.langIndex = options.langIndex || PDU_NL_IDENTIFIER_DEFAULT;

     options.langShiftIndex = options.langShiftIndex || PDU_NL_IDENTIFIER_DEFAULT;

     if (!options.retryCount) {

       options.retryCount = 0;

     }

     if (!options.segmentSeq) {

       // Fist segment to send

       options.segmentSeq = 1;

       options.body = options.segments[0].body;

       options.encodedBodyLength = options.segments[0].encodedBodyLength;

     }

     let Buf = this.context.Buf;

     if (this._isCdma) {

       Buf.newParcel(REQUEST_CDMA_SEND_SMS, options);

       this.context.CdmaPDUHelper.writeMessage(options);

     } else {

       Buf.newParcel(REQUEST_SEND_SMS, options);

       Buf.writeInt32(2);

       Buf.writeString(options.SMSC);

       this.context.GsmPDUHelper.writeMessage(options);

     }

     Buf.sendParcel();

   },

   /**

    * Acknowledge the receipt and handling of an SMS.

    *

    * @param success

    *        Boolean indicating whether the message was successfuly handled.

    * @param cause

    *        SMS_* constant indicating the reason for unsuccessful handling.

    */

   acknowledgeGsmSms: function(success, cause) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SMS_ACKNOWLEDGE);

     Buf.writeInt32(2);

     Buf.writeInt32(success ? 1 : 0);

     Buf.writeInt32(cause);

     Buf.sendParcel();

   },

   /**

    * Acknowledge the receipt and handling of an SMS.

    *

    * @param success

    *        Boolean indicating whether the message was successfuly handled.

    */

   ackSMS: function(options) {

     if (options.result == PDU_FCS_RESERVED) {

       return;

     }

     if (this._isCdma) {

       this.acknowledgeCdmaSms(options.result == PDU_FCS_OK, options.result);

     } else {

       this.acknowledgeGsmSms(options.result == PDU_FCS_OK, options.result);

     }

   },

   /**

    * Acknowledge the receipt and handling of a CDMA SMS.

    *

    * @param success

    *        Boolean indicating whether the message was successfuly handled.

    * @param cause

    *        SMS_* constant indicating the reason for unsuccessful handling.

    */

   acknowledgeCdmaSms: function(success, cause) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_CDMA_SMS_ACKNOWLEDGE);

     Buf.writeInt32(success ? 0 : 1);

     Buf.writeInt32(cause);

     Buf.sendParcel();

   },

   /**

    * Update received MWI into EF_MWIS.

    */

   updateMwis: function(options) {

     if (this.context.ICCUtilsHelper.isICCServiceAvailable("MWIS")) {

       this.context.SimRecordHelper.updateMWIS(options.mwi);

     }

   },

   setCellBroadcastDisabled: function(options) {

     this.cellBroadcastDisabled = options.disabled;

     // If |this.mergedCellBroadcastConfig| is null, either we haven't finished

     // reading required SIM files, or no any channel is ever configured.  In

     // the former case, we'll call |this.updateCellBroadcastConfig()| later

     // with correct configs; in the latter case, we don't bother resetting CB

     // to disabled again.

     if (this.mergedCellBroadcastConfig) {

       this.updateCellBroadcastConfig();

     }

   },

   setCellBroadcastSearchList: function(options) {

     let getSearchListStr = function(aSearchList) {

       if (typeof aSearchList === "string" || aSearchList instanceof String) {

         return aSearchList;

       }

       // TODO: Set search list for CDMA/GSM individually. Bug 990926

       let prop = this._isCdma ? "cdma" : "gsm";

       return aSearchList && aSearchList[prop];

     }.bind(this);

     try {

       let str = getSearchListStr(options.searchList);

       this.cellBroadcastConfigs.MMI = this._convertCellBroadcastSearchList(str);

       options.success = true;

     } catch (e) {

       if (DEBUG) {

         this.context.debug("Invalid Cell Broadcast search list: " + e);

       }

       options.success = false;

     }

     this.sendChromeMessage(options);

     if (!options.success) {

       return;

     }

     this._mergeAllCellBroadcastConfigs();

   },

   updateCellBroadcastConfig: function() {

     let activate = !this.cellBroadcastDisabled &&

                    (this.mergedCellBroadcastConfig != null) &&

                    (this.mergedCellBroadcastConfig.length > 0);

     if (activate) {

       this.setSmsBroadcastConfig(this.mergedCellBroadcastConfig);

     } else {

       // It's unnecessary to set config first if we're deactivating.

       this.setSmsBroadcastActivation(false);

     }

   },

   setGsmSmsBroadcastConfig: function(config) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_GSM_SET_BROADCAST_SMS_CONFIG);

     let numConfigs = config ? config.length / 2 : 0;

     Buf.writeInt32(numConfigs);

     for (let i = 0; i < config.length;) {

       Buf.writeInt32(config[i++]);

       Buf.writeInt32(config[i++]);

       Buf.writeInt32(0x00);

       Buf.writeInt32(0xFF);

       Buf.writeInt32(1);

     }

     Buf.sendParcel();

   },

   /**

    * Send CDMA SMS broadcast config.

    *

    * @see 3GPP2 C.R1001 Sec. 9.2 and 9.3

    */

   setCdmaSmsBroadcastConfig: function(config) {

     let Buf = this.context.Buf;

     // |config| is an array of half-closed range: [[from, to), [from, to), ...].

     // It will be further decomposed, ex: [1, 4) => 1, 2, 3.

     Buf.newParcel(REQUEST_CDMA_SET_BROADCAST_SMS_CONFIG);

     let numConfigs = 0;

     for (let i = 0; i < config.length; i += 2) {

       numConfigs += (config[i+1] - config[i]);

     }

     Buf.writeInt32(numConfigs);

     for (let i = 0; i < config.length;) {

       let begin = config[i++];

       let end = config[i++];

       for (let j = begin; j < end; ++j) {

         Buf.writeInt32(j);

         Buf.writeInt32(0);  // Language Indicator: Unknown or unspecified.

         Buf.writeInt32(1);

       }

     }

     Buf.sendParcel();

   },

   setSmsBroadcastConfig: function(config) {

     if (this._isCdma) {

       this.setCdmaSmsBroadcastConfig(config);

     } else {

       this.setGsmSmsBroadcastConfig(config);

     }

   },

   setSmsBroadcastActivation: function(activate) {

     let parcelType = this._isCdma ? REQUEST_CDMA_SMS_BROADCAST_ACTIVATION :

                                     REQUEST_GSM_SMS_BROADCAST_ACTIVATION;

     let Buf = this.context.Buf;

     Buf.newParcel(parcelType);

     Buf.writeInt32(1);

     // See hardware/ril/include/telephony/ril.h, 0 - Activate, 1 - Turn off.

     Buf.writeInt32(activate ? 0 : 1);

     Buf.sendParcel();

   },

   /**

    * Start a DTMF Tone.

    *

    * @param dtmfChar

    *        DTMF signal to send, 0-9, *, +

    */

   startTone: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_DTMF_START);

     Buf.writeString(options.dtmfChar);

     Buf.sendParcel();

   },

   stopTone: function() {

     this.context.Buf.simpleRequest(REQUEST_DTMF_STOP);

   },

   /**

    * Send a DTMF tone.

    *

    * @param dtmfChar

    *        DTMF signal to send, 0-9, *, +

    */

   sendTone: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_DTMF);

     Buf.writeString(options.dtmfChar);

     Buf.sendParcel();

   },

   /**

    * Get the Short Message Service Center address.

    */

   getSmscAddress: function(options) {

     if (!this.SMSC) {

       this.context.Buf.simpleRequest(REQUEST_GET_SMSC_ADDRESS, options);

       return;

     }

     if (!options || options.rilMessageType !== "getSmscAddress") {

       return;

     }

     options.smscAddress = this.SMSC;

     options.errorMsg = RIL_ERROR_TO_GECKO_ERROR[options.rilRequestError];

     this.sendChromeMessage(options);

   },

   /**

    * Set the Short Message Service Center address.

    *

    * @param smscAddress

    *        Short Message Service Center address in PDU format.

    */

   setSmscAddress: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_SMSC_ADDRESS, options);

     Buf.writeString(options.smscAddress);

     Buf.sendParcel();

   },

   /**

    * Setup a data call.

    *

    * @param radioTech

    *        Integer to indicate radio technology.

    *        DATACALL_RADIOTECHNOLOGY_CDMA => CDMA.

    *        DATACALL_RADIOTECHNOLOGY_GSM  => GSM.

    * @param apn

    *        String containing the name of the APN to connect to.

    * @param user

    *        String containing the username for the APN.

    * @param passwd

    *        String containing the password for the APN.

    * @param chappap

    *        Integer containing CHAP/PAP auth type.

    *        DATACALL_AUTH_NONE        => PAP and CHAP is never performed.

    *        DATACALL_AUTH_PAP         => PAP may be performed.

    *        DATACALL_AUTH_CHAP        => CHAP may be performed.

    *        DATACALL_AUTH_PAP_OR_CHAP => PAP / CHAP may be performed.

    * @param pdptype

    *        String containing PDP type to request. ("IP", "IPV6", ...)

    */

   setupDataCall: function(options) {

     // From ./hardware/ril/include/telephony/ril.h:

     // ((const char **)data)[0] Radio technology to use: 0-CDMA, 1-GSM/UMTS, 2...

     // for values above 2 this is RIL_RadioTechnology + 2.

     //

     // From frameworks/base/telephony/java/com/android/internal/telephony/DataConnection.java:

     // if the mRilVersion < 6, radio technology must be GSM/UMTS or CDMA.

     // Otherwise, it must be + 2

     //

     // See also bug 901232 and 867873

     let radioTech;

     if (this.v5Legacy) {

       radioTech = this._isCdma ? DATACALL_RADIOTECHNOLOGY_CDMA

                                : DATACALL_RADIOTECHNOLOGY_GSM;

     } else {

       radioTech = options.radioTech + 2;

     }

     let Buf = this.context.Buf;

     let token = Buf.newParcel(REQUEST_SETUP_DATA_CALL, options);

     Buf.writeInt32(7);

     Buf.writeString(radioTech.toString());

     Buf.writeString(DATACALL_PROFILE_DEFAULT.toString());

     Buf.writeString(options.apn);

     Buf.writeString(options.user);

     Buf.writeString(options.passwd);

     Buf.writeString(options.chappap.toString());

     Buf.writeString(options.pdptype);

     Buf.sendParcel();

     return token;

   },

   /**

    * Deactivate a data call.

    *

    * @param cid

    *        String containing CID.

    * @param reason

    *        One of DATACALL_DEACTIVATE_* constants.

    */

   deactivateDataCall: function(options) {

     let datacall = this.currentDataCalls[options.cid];

     if (!datacall) {

       return;

     }

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_DEACTIVATE_DATA_CALL, options);

     Buf.writeInt32(2);

     Buf.writeString(options.cid);

     Buf.writeString(options.reason || DATACALL_DEACTIVATE_NO_REASON);

     Buf.sendParcel();

     datacall.state = GECKO_NETWORK_STATE_DISCONNECTING;

     this.sendChromeMessage(datacall);

   },

   /**

    * Get a list of data calls.

    */

   getDataCallList: function() {

     this.context.Buf.simpleRequest(REQUEST_DATA_CALL_LIST);

   },

   _attachDataRegistration: false,

   /**

    * Manually attach/detach data registration.

    *

    * @param attach

    *        Boolean value indicating attach or detach.

    */

   setDataRegistration: function(options) {

     let request = options.attach ? RIL_REQUEST_GPRS_ATTACH :

                                    RIL_REQUEST_GPRS_DETACH;

     this._attachDataRegistration = options.attach;

     this.context.Buf.simpleRequest(request);

   },

   /**

    * Get failure casue code for the most recently failed PDP context.

    */

   getFailCauseCode: function(callback) {

     this.context.Buf.simpleRequest(REQUEST_LAST_CALL_FAIL_CAUSE,

                                    {callback: callback});

   },

   /**

    * Helper to parse MMI/USSD string. TS.22.030 Figure 3.5.3.2.

    */

   _parseMMI: function(mmiString) {

     if (!mmiString || !mmiString.length) {

       return null;

     }

     let matches = this._matchMMIRegexp(mmiString);

     if (matches) {

       // After successfully executing the regular expresion over the MMI string,

       // the following match groups should contain:

       // 1 = full MMI string that might be used as a USSD request.

       // 2 = MMI procedure.

       // 3 = Service code.

       // 5 = SIA.

       // 7 = SIB.

       // 9 = SIC.

       // 11 = Password registration.

       // 12 = Dialing number.

       return {

         fullMMI: matches[MMI_MATCH_GROUP_FULL_MMI],

         procedure: matches[MMI_MATCH_GROUP_MMI_PROCEDURE],

         serviceCode: matches[MMI_MATCH_GROUP_SERVICE_CODE],

         sia: matches[MMI_MATCH_GROUP_SIA],

         sib: matches[MMI_MATCH_GROUP_SIB],

         sic: matches[MMI_MATCH_GROUP_SIC],

         pwd: matches[MMI_MATCH_GROUP_PWD_CONFIRM],

         dialNumber: matches[MMI_MATCH_GROUP_DIALING_NUMBER]

       };

     }

     if (this._isPoundString(mmiString) ||

         this._isMMIShortString(mmiString)) {

       return {

         fullMMI: mmiString

       };

     }

     return null;

   },

   /**

    * Helper to parse MMI string via regular expression. TS.22.030 Figure

    * 3.5.3.2.

    */

   _matchMMIRegexp: function(mmiString) {

     // Regexp to parse and process the MMI code.

     if (this._mmiRegExp == null) {

       // The first group of the regexp takes the whole MMI string.

       // The second group takes the MMI procedure that can be:

       //    - Activation (*SC*SI#).

       //    - Deactivation (#SC*SI#).

       //    - Interrogation (*#SC*SI#).

       //    - Registration (**SC*SI#).

       //    - Erasure (##SC*SI#).

       //  where SC = Service Code (2 or 3 digits) and SI = Supplementary Info

       //  (variable length).

       let pattern = "((\\*[*#]?|##?)";

       // Third group of the regexp looks for the MMI Service code, which is a

       // 2 or 3 digits that uniquely specifies the Supplementary Service

       // associated with the MMI code.

       pattern += "(\\d{2,3})";

       // Groups from 4 to 9 looks for the MMI Supplementary Information SIA,

       // SIB and SIC. SIA may comprise e.g. a PIN code or Directory Number,

       // SIB may be used to specify the tele or bearer service and SIC to

       // specify the value of the "No Reply Condition Timer". Where a particular

       // service request does not require any SI, "*SI" is not entered. The use

       // of SIA, SIB and SIC is optional and shall be entered in any of the

       // following formats:

       //    - *SIA*SIB*SIC#

       //    - *SIA*SIB#

       //    - *SIA**SIC#

       //    - *SIA#

       //    - **SIB*SIC#

       //    - ***SISC#

       pattern += "(\\*([^*#]*)(\\*([^*#]*)(\\*([^*#]*)";

       // The eleventh group takes the password for the case of a password

       // registration procedure.

       pattern += "(\\*([^*#]*))?)?)?)?#)";

       // The last group takes the dial string after the #.

       pattern += "([^#]*)";

       this._mmiRegExp = new RegExp(pattern);

     }

     // Regex only applys for those well-defined MMI strings (refer to TS.22.030

     // Annex B), otherwise, null should be the expected return value.

     return this._mmiRegExp.exec(mmiString);

   },

   /**

    * Helper to parse # string. TS.22.030 Figure 3.5.3.2.

    */

   _isPoundString: function(mmiString) {

     return (mmiString.charAt(mmiString.length - 1) === MMI_END_OF_USSD);

   },

   /**

    * Helper to parse short string. TS.22.030 Figure 3.5.3.2.

    */

   _isMMIShortString: function(mmiString) {

     if (mmiString.length > 2) {

       return false;

     }

     if (this._isEmergencyNumber(mmiString)) {

       return false;

     }

     // In a call case.

     if (Object.getOwnPropertyNames(this.currentCalls).length > 0) {

       return true;

     }

     if ((mmiString.length != 2) || (mmiString.charAt(0) !== '1')) {

       return true;

     }

     return false;

   },

   sendMMI: function(options) {

     if (DEBUG) {

       this.context.debug("SendMMI " + JSON.stringify(options));

     }

     let mmiString = options.mmi;

     let mmi = this._parseMMI(mmiString);

     let _sendMMIError = (function(errorMsg, mmiServiceCode) {

       options.success = false;

       options.errorMsg = errorMsg;

       if (mmiServiceCode) {

         options.mmiServiceCode = mmiServiceCode;

       }

       this.sendChromeMessage(options);

     }).bind(this);

     function _isValidPINPUKRequest(mmiServiceCode) {

       // The only allowed MMI procedure for ICC PIN, PIN2, PUK and PUK2 handling

       // is "Registration" (**).

       if (!mmi.procedure || mmi.procedure != MMI_PROCEDURE_REGISTRATION ) {

         _sendMMIError(MMI_ERROR_KS_INVALID_ACTION, mmiServiceCode);

         return false;

       }

       if (!mmi.sia || !mmi.sia.length || !mmi.sib || !mmi.sib.length ||

           !mmi.sic || !mmi.sic.length) {

         _sendMMIError(MMI_ERROR_KS_ERROR, mmiServiceCode);

         return false;

       }

       if (mmi.sib != mmi.sic) {

         _sendMMIError(MMI_ERROR_KS_MISMATCH_PIN, mmiServiceCode);

         return false;

       }

       if (mmi.sia.length < 4 || mmi.sia.length > 8 ||

           mmi.sib.length < 4 || mmi.sib.length > 8 ||

           mmi.sic.length < 4 || mmi.sic.length > 8) {

         _sendMMIError(MMI_ERROR_KS_INVALID_PIN, mmiServiceCode);

         return false;

       }

       return true;

     }

     let _isRadioAvailable = (function(mmiServiceCode) {

       if (this.radioState !== GECKO_RADIOSTATE_READY) {

         _sendMMIError(GECKO_ERROR_RADIO_NOT_AVAILABLE, mmiServiceCode);

         return false;

       }

       return true;

     }).bind(this);

     // If we couldn't parse the MMI code, we'll send it as an USSD request.

     if (mmi === null) {

       if (this._ussdSession) {

         if (!_isRadioAvailable(MMI_KS_SC_USSD)) {

           return;

         }

         options.ussd = mmiString;

         this.sendUSSD(options);

         return;

       }

       _sendMMIError(MMI_ERROR_KS_ERROR);

       return;

     }

     if (DEBUG) {

       this.context.debug("MMI " + JSON.stringify(mmi));

     }

     // We check if the MMI service code is supported and in that case we

     // trigger the appropriate RIL request if possible.

     let sc = mmi.serviceCode;

     switch (sc) {

       // Call forwarding

       case MMI_SC_CFU:

       case MMI_SC_CF_BUSY:

       case MMI_SC_CF_NO_REPLY:

       case MMI_SC_CF_NOT_REACHABLE:

       case MMI_SC_CF_ALL:

       case MMI_SC_CF_ALL_CONDITIONAL:

         if (!_isRadioAvailable(MMI_KS_SC_CALL_FORWARDING)) {

           return;

         }

         // Call forwarding requires at least an action, given by the MMI

         // procedure, and a reason, given by the MMI service code, but there

         // is no way that we get this far without a valid procedure or service

         // code.

         options.mmiServiceCode = MMI_KS_SC_CALL_FORWARDING;

         options.action = MMI_PROC_TO_CF_ACTION[mmi.procedure];

         options.reason = MMI_SC_TO_CF_REASON[sc];

         options.number = mmi.sia;

         options.serviceClass = this._siToServiceClass(mmi.sib);

         if (options.action == CALL_FORWARD_ACTION_QUERY_STATUS) {

           this.queryCallForwardStatus(options);

           return;

         }

         options.isSetCallForward = true;

         options.timeSeconds = mmi.sic;

         this.setCallForward(options);

         return;

       // Change the current ICC PIN number.

       case MMI_SC_PIN:

         // As defined in TS.122.030 6.6.2 to change the ICC PIN we should expect

         // an MMI code of the form **04*OLD_PIN*NEW_PIN*NEW_PIN#, where old PIN

         // should be entered as the SIA parameter and the new PIN as SIB and

         // SIC.

         if (!_isRadioAvailable(MMI_KS_SC_PIN) ||

             !_isValidPINPUKRequest(MMI_KS_SC_PIN)) {

           return;

         }

         options.mmiServiceCode = MMI_KS_SC_PIN;

         options.pin = mmi.sia;

         options.newPin = mmi.sib;

         this.changeICCPIN(options);

         return;

       // Change the current ICC PIN2 number.

       case MMI_SC_PIN2:

         // As defined in TS.122.030 6.6.2 to change the ICC PIN2 we should

         // enter and MMI code of the form **042*OLD_PIN2*NEW_PIN2*NEW_PIN2#,

         // where the old PIN2 should be entered as the SIA parameter and the

         // new PIN2 as SIB and SIC.

         if (!_isRadioAvailable(MMI_KS_SC_PIN2) ||

             !_isValidPINPUKRequest(MMI_KS_SC_PIN2)) {

           return;

         }

         options.mmiServiceCode = MMI_KS_SC_PIN2;

         options.pin = mmi.sia;

         options.newPin = mmi.sib;

         this.changeICCPIN2(options);

         return;

       // Unblock ICC PIN.

       case MMI_SC_PUK:

         // As defined in TS.122.030 6.6.3 to unblock the ICC PIN we should

         // enter an MMI code of the form **05*PUK*NEW_PIN*NEW_PIN#, where PUK

         // should be entered as the SIA parameter and the new PIN as SIB and

         // SIC.

         if (!_isRadioAvailable(MMI_KS_SC_PUK) ||

             !_isValidPINPUKRequest(MMI_KS_SC_PUK)) {

           return;

         }

         options.mmiServiceCode = MMI_KS_SC_PUK;

         options.puk = mmi.sia;

         options.newPin = mmi.sib;

         this.enterICCPUK(options);

         return;

       // Unblock ICC PIN2.

       case MMI_SC_PUK2:

         // As defined in TS.122.030 6.6.3 to unblock the ICC PIN2 we should

         // enter an MMI code of the form **052*PUK2*NEW_PIN2*NEW_PIN2#, where

         // PUK2 should be entered as the SIA parameter and the new PIN2 as SIB

         // and SIC.

         if (!_isRadioAvailable(MMI_KS_SC_PUK2) ||

             !_isValidPINPUKRequest(MMI_KS_SC_PUK2)) {

           return;

         }

         options.mmiServiceCode = MMI_KS_SC_PUK2;

         options.puk = mmi.sia;

         options.newPin = mmi.sib;

         this.enterICCPUK2(options);

         return;

       // IMEI

       case MMI_SC_IMEI:

         // A device's IMEI can't change, so we only need to request it once.

         if (this.IMEI == null) {

           this.getIMEI(options);

           return;

         }

         // If we already had the device's IMEI, we just send it to chrome.

         options.mmiServiceCode = MMI_KS_SC_IMEI;

         options.success = true;

         options.statusMessage = this.IMEI;

         this.sendChromeMessage(options);

         return;

       // CLIP

       case MMI_SC_CLIP:

         options.mmiServiceCode = MMI_KS_SC_CLIP;

         options.procedure = mmi.procedure;

         if (options.procedure === MMI_PROCEDURE_INTERROGATION) {

           this.queryCLIP(options);

         } else {

           _sendMMIError(MMI_ERROR_KS_NOT_SUPPORTED, MMI_KS_SC_CLIP);

         }

         return;

       // CLIR (non-temporary ones)

       // TODO: Both dial() and sendMMI() functions should be unified at some

       // point in the future. In the mean time we handle temporary CLIR MMI

       // commands through the dial() function. Please see bug 889737.

       case MMI_SC_CLIR:

         options.mmiServiceCode = MMI_KS_SC_CLIR;

         options.procedure = mmi.procedure;

         switch (options.procedure) {

           case MMI_PROCEDURE_INTERROGATION:

             this.getCLIR(options);

             return;

           case MMI_PROCEDURE_ACTIVATION:

             options.clirMode = CLIR_INVOCATION;

             break;

           case MMI_PROCEDURE_DEACTIVATION:

             options.clirMode = CLIR_SUPPRESSION;

             break;

           default:

             _sendMMIError(MMI_ERROR_KS_NOT_SUPPORTED, MMI_KS_SC_CLIR);

             return;

         }

         options.isSetCLIR = true;

         this.setCLIR(options);

         return;

       // Call barring

       case MMI_SC_BAOC:

       case MMI_SC_BAOIC:

       case MMI_SC_BAOICxH:

       case MMI_SC_BAIC:

       case MMI_SC_BAICr:

       case MMI_SC_BA_ALL:

       case MMI_SC_BA_MO:

       case MMI_SC_BA_MT:

         options.mmiServiceCode = MMI_KS_SC_CALL_BARRING;

         options.password = mmi.sia || "";

         options.serviceClass = this._siToServiceClass(mmi.sib);

         options.facility = MMI_SC_TO_CB_FACILITY[sc];

         options.procedure = mmi.procedure;

         if (mmi.procedure === MMI_PROCEDURE_INTERROGATION) {

           this.queryICCFacilityLock(options);

           return;

         }

         if (mmi.procedure === MMI_PROCEDURE_ACTIVATION) {

           options.enabled = 1;

         } else if (mmi.procedure === MMI_PROCEDURE_DEACTIVATION) {

           options.enabled = 0;

         } else {

           _sendMMIError(MMI_ERROR_KS_NOT_SUPPORTED, MMI_KS_SC_CALL_BARRING);

           return;

         }

         this.setICCFacilityLock(options);

         return;

       // Call waiting

       case MMI_SC_CALL_WAITING:

         if (!_isRadioAvailable(MMI_KS_SC_CALL_WAITING)) {

           return;

         }

         options.mmiServiceCode = MMI_KS_SC_CALL_WAITING;

         if (mmi.procedure === MMI_PROCEDURE_INTERROGATION) {

           this._handleQueryMMICallWaiting(options);

           return;

         }

         if (mmi.procedure === MMI_PROCEDURE_ACTIVATION) {

           options.enabled = true;

         } else if (mmi.procedure === MMI_PROCEDURE_DEACTIVATION) {

           options.enabled = false;

         } else {

           _sendMMIError(MMI_ERROR_KS_NOT_SUPPORTED, MMI_KS_SC_CALL_WAITING);

           return;

         }

         options.serviceClass = this._siToServiceClass(mmi.sia);

         this._handleSetMMICallWaiting(options);

         return;

     }

     // If the MMI code is not a known code and is a recognized USSD request,

     // it shall still be sent as a USSD request.

     if (mmi.fullMMI) {

       if (!_isRadioAvailable(MMI_KS_SC_USSD)) {

         return;

       }

       options.ussd = mmi.fullMMI;

       options.mmiServiceCode = MMI_KS_SC_USSD;

       this.sendUSSD(options);

       return;

     }

     // At this point, the MMI string is considered as not valid MMI code and

     // not valid USSD code.

     _sendMMIError(MMI_ERROR_KS_ERROR);

   },

   /**

    * Send USSD.

    *

    * @param ussd

    *        String containing the USSD code.

    *

    */

    sendUSSD: function(options) {

      let Buf = this.context.Buf;

      Buf.newParcel(REQUEST_SEND_USSD, options);

      Buf.writeString(options.ussd);

      Buf.sendParcel();

    },

   /**

    * Cancel pending USSD.

    */

    cancelUSSD: function(options) {

      options.mmiServiceCode = MMI_KS_SC_USSD;

      this.context.Buf.simpleRequest(REQUEST_CANCEL_USSD, options);

    },

   /**

    * Queries current call forward rules.

    *

    * @param reason

    *        One of nsIDOMMozMobileCFInfo.CALL_FORWARD_REASON_* constants.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_* constants.

    * @param number

    *        Phone number of forwarding address.

    */

   queryCallForwardStatus: function(options) {

     let Buf = this.context.Buf;

     let number = options.number || "";

     Buf.newParcel(REQUEST_QUERY_CALL_FORWARD_STATUS, options);

     Buf.writeInt32(CALL_FORWARD_ACTION_QUERY_STATUS);

     Buf.writeInt32(options.reason);

     Buf.writeInt32(options.serviceClass || ICC_SERVICE_CLASS_NONE);

     Buf.writeInt32(this._toaFromString(number));

     Buf.writeString(number);

     Buf.writeInt32(0);

     Buf.sendParcel();

   },

   /**

    * Configures call forward rule.

    *

    * @param action

    *        One of nsIDOMMozMobileCFInfo.CALL_FORWARD_ACTION_* constants.

    * @param reason

    *        One of nsIDOMMozMobileCFInfo.CALL_FORWARD_REASON_* constants.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_* constants.

    * @param number

    *        Phone number of forwarding address.

    * @param timeSeconds

    *        Time in seconds to wait beforec all is forwarded.

    */

   setCallForward: function(options) {

     let Buf = this.context.Buf;

     Buf.newParcel(REQUEST_SET_CALL_FORWARD, options);

     Buf.writeInt32(options.action);

     Buf.writeInt32(options.reason);

     Buf.writeInt32(options.serviceClass);

     Buf.writeInt32(this._toaFromString(options.number));

     Buf.writeString(options.number);

     Buf.writeInt32(options.timeSeconds);

     Buf.sendParcel();

   },

   /**

    * Queries current call barring rules.

    *

    * @param program

    *        One of nsIDOMMozMobileConnection.CALL_BARRING_PROGRAM_* constants.

    * @param serviceClass

    *        One of ICC_SERVICE_CLASS_* constants.

    */

   queryCallBarringStatus: function(options) {

     options.facility = CALL_BARRING_PROGRAM_TO_FACILITY[options.program];

     options.password = ""; // For query no need to provide it.

     this.queryICCFacilityLock(options);

   },

   /**

    * Configures call barring rule.

    *

    * @param program

    *        One of nsIDOMMozMobileConnection.CALL_BARRING_PROGRAM_* constants.

    * @param enabled

    *        Enable or disable the call barring.

    * @param password