diff --git a/file_contexts b/file_contexts new file mode 100644 index 0000000..956db6b --- /dev/null +++ b/file_contexts @@ -0,0 +1,39 @@ +# Bluetooth +/efs/bluetooth/bt_addr u:object_r:bluetooth_efs_file:s0 + +# Camera +/data/cam_socket.* u:object_r:camera_socket:s0 +/sys/devices/virtual/camera(/.*)? u:object_r:sysfs_camera:s0 + +# CMHW +/sys/devices/virtual/timed_output/vibrator(/.*)? u:object_r:sysfs_vibeamp:s0 +/sys/class/sec/sec_touchkey/keypad_enable u:object_r:sysfs_display:s0 + +# Display +/sys/devices/fd922800.qcom,mdss_dsi/lcd/panel/power_reduce u:object_r:sysfs_display:s0 + +# EFS +/dev/block/platform/msm_sdcc.1/by-name/efs u:object_r:efs_block_device:s0 + +# Fingerprint +/system/bin/vcsFPService u:object_r:vcs_exec:s0 +/data/validity(/.*)? u:object_r:vcs_data_file:s0 +/dev/validity(/.*)? u:object_r:vcs_device:s0 +/dev/vfsspi u:object_r:vcs_device:s0 + +# NFC +/dev/pn547 u:object_r:nfc_device:s0 + +# Sensors +/dev/alps_io u:object_r:io_device:s0 +/dev/iio:device0 u:object_r:io_device:s0 +/efs/FactoryApp/baro_delta u:object_r:sensors_efs_file:s0 +/efs/gyro_cal_data u:object_r:sensors_efs_file:s0 +/efs/prox_cal u:object_r:sensors_efs_file:s0 + +# Thermal engine +/system/bin/thermal-engine u:object_r:thermal-engine_exec:s0 + +# WiFi +/data/.wifiver.info u:object_r:wifi_data_file:s0 +/efs/wifi/.mac.info u:object_r:wifi_efs_file:s0 diff --git a/property_contexts b/property_contexts new file mode 100644 index 0000000..8e1ff08 --- /dev/null +++ b/property_contexts @@ -0,0 +1,2 @@ +persist.sys.camera.preview u:object_r:camera_prop:s0 +sys.qseecomd.enable u:object_r:qseecomd_prop:s0 diff --git a/ril_class/SerranoRIL.java b/ril_class/SerranoRIL.java new file mode 100644 index 0000000..52cb7be --- /dev/null +++ b/ril_class/SerranoRIL.java @@ -0,0 +1,629 @@ +/* + * Copyright (C) 2013-2016, The CyanogenMod Project + * Copyright (C) 2017, The LineageOS Project + * + * 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. + */ + +package com.android.internal.telephony; + +import static com.android.internal.telephony.RILConstants.*; + +import android.content.Context; +import android.telephony.Rlog; +import android.os.AsyncResult; +import android.os.Message; +import android.os.Parcel; +import android.os.SystemClock; +import android.os.SystemProperties; +import android.telephony.ModemActivityInfo; +import android.telephony.PhoneNumberUtils; +import android.telephony.SignalStrength; +import com.android.internal.telephony.cdma.CdmaInformationRecords; +import com.android.internal.telephony.cdma.CdmaInformationRecords.CdmaSignalInfoRec; +import com.android.internal.telephony.cdma.SignalToneUtil; +import com.android.internal.telephony.gsm.SmsBroadcastConfigInfo; +import com.android.internal.telephony.uicc.IccCardApplicationStatus; +import com.android.internal.telephony.uicc.IccCardStatus; +import com.android.internal.telephony.uicc.IccUtils; +import java.util.ArrayList; +import java.util.Collections; + +/** + * RIL customization for Galaxy S4 Mini (GSM/CDMA) devices + * + * {@hide} + */ +public class SerranoRIL extends RIL { + + private static final int RIL_REQUEST_DIAL_EMERGENCY = 10016; + private static final int RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED = 1036; + private static final int RIL_UNSOL_DEVICE_READY_NOTI = 11008; + private static final int RIL_UNSOL_AM = 11010; + private static final int RIL_UNSOL_WB_AMR_STATE = 11017; + private static final int RIL_UNSOL_RESPONSE_HANDOVER = 11021; + private static final int RIL_UNSOL_ON_SS_SAMSUNG = 1040; + private static final int RIL_UNSOL_STK_CC_ALPHA_NOTIFY_SAMSUNG = 1041; + private static final int RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED_SAMSUNG = 11031; + + private Object mSMSLock = new Object(); + private boolean mIsSendingSMS = false; + public static final long SEND_SMS_TIMEOUT_IN_MS = 30000; + protected boolean isGSM = false; + + public SerranoRIL(Context context, int preferredNetworkType, int cdmaSubscription) { + this(context, preferredNetworkType, cdmaSubscription, null); + } + + public SerranoRIL(Context context, int preferredNetworkType, + int cdmaSubscription, Integer instanceId) { + super(context, preferredNetworkType, cdmaSubscription, instanceId); + } + + @Override + public void + dial(String address, int clirMode, UUSInfo uusInfo, Message result) { + if (PhoneNumberUtils.isEmergencyNumber(address)) { + dialEmergencyCall(address, clirMode, result); + return; + } + + RILRequest rr = RILRequest.obtain(RIL_REQUEST_DIAL, result); + + rr.mParcel.writeString(address); + rr.mParcel.writeInt(clirMode); + rr.mParcel.writeInt(0); // CallDetails.call_type + rr.mParcel.writeInt(1); // CallDetails.call_domain + rr.mParcel.writeString(""); // CallDetails.getCsvFromExtras + + if (uusInfo == null) { + rr.mParcel.writeInt(0); // UUS information is absent + } else { + rr.mParcel.writeInt(1); // UUS information is present + rr.mParcel.writeInt(uusInfo.getType()); + rr.mParcel.writeInt(uusInfo.getDcs()); + rr.mParcel.writeByteArray(uusInfo.getUserData()); + } + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + @Override + protected Object + responseIccCardStatus(Parcel p) { + IccCardApplicationStatus appStatus; + + IccCardStatus cardStatus = new IccCardStatus(); + cardStatus.setCardState(p.readInt()); + cardStatus.setUniversalPinState(p.readInt()); + cardStatus.mGsmUmtsSubscriptionAppIndex = p.readInt(); + cardStatus.mCdmaSubscriptionAppIndex = p.readInt(); + cardStatus.mImsSubscriptionAppIndex = p.readInt(); + + int numApplications = p.readInt(); + + // limit to maximum allowed applications + if (numApplications > IccCardStatus.CARD_MAX_APPS) { + numApplications = IccCardStatus.CARD_MAX_APPS; + } + cardStatus.mApplications = new IccCardApplicationStatus[numApplications]; + + for (int i = 0 ; i < numApplications ; i++) { + appStatus = new IccCardApplicationStatus(); + appStatus.app_type = appStatus.AppTypeFromRILInt(p.readInt()); + appStatus.app_state = appStatus.AppStateFromRILInt(p.readInt()); + appStatus.perso_substate = appStatus.PersoSubstateFromRILInt(p.readInt()); + appStatus.aid = p.readString(); + appStatus.app_label = p.readString(); + appStatus.pin1_replaced = p.readInt(); + appStatus.pin1 = appStatus.PinStateFromRILInt(p.readInt()); + appStatus.pin2 = appStatus.PinStateFromRILInt(p.readInt()); + p.readInt(); // pin1_num_retries + p.readInt(); // puk1_num_retries + p.readInt(); // pin2_num_retries + p.readInt(); // puk2_num_retries + p.readInt(); // perso_unblock_retries + + cardStatus.mApplications[i] = appStatus; + } + return cardStatus; + } + + @Override + public void + sendCdmaSms(byte[] pdu, Message result) { + smsLock(); + super.sendCdmaSms(pdu, result); + } + + @Override + public void + sendSMS (String smscPDU, String pdu, Message result) { + smsLock(); + super.sendSMS(smscPDU, pdu, result); + } + + @Override + protected Object + responseSMS(Parcel p) { + // Notify that sendSMS() can send the next SMS + synchronized (mSMSLock) { + mIsSendingSMS = false; + mSMSLock.notify(); + } + + return super.responseSMS(p); + } + + private void smsLock(){ + // Do not send a new SMS until the response for the previous SMS has been received + // * for the error case where the response never comes back, time out after + // 30 seconds and just try the next SEND_SMS + synchronized (mSMSLock) { + long timeoutTime = SystemClock.elapsedRealtime() + SEND_SMS_TIMEOUT_IN_MS; + long waitTimeLeft = SEND_SMS_TIMEOUT_IN_MS; + while (mIsSendingSMS && (waitTimeLeft > 0)) { + Rlog.d(RILJ_LOG_TAG, "sendSMS() waiting for response of previous SEND_SMS"); + try { + mSMSLock.wait(waitTimeLeft); + } catch (InterruptedException ex) { + // ignore the interrupt and rewait for the remainder + } + waitTimeLeft = timeoutTime - SystemClock.elapsedRealtime(); + } + if (waitTimeLeft <= 0) { + Rlog.e(RILJ_LOG_TAG, "sendSms() timed out waiting for response of previous CDMA_SEND_SMS"); + } + mIsSendingSMS = true; + } + } + + @Override + protected Object + responseCallList(Parcel p) { + int num; + ArrayList response; + DriverCall dc; + + num = p.readInt(); + response = new ArrayList(num); + + if (RILJ_LOGV) { + riljLog("responseCallList: num=" + num + + " mEmergencyCallbackModeRegistrant=" + mEmergencyCallbackModeRegistrant + + " mTestingEmergencyCall=" + mTestingEmergencyCall.get()); + } + for (int i = 0 ; i < num ; i++) { + dc = new DriverCall(); + + dc.state = DriverCall.stateFromCLCC(p.readInt()); + dc.index = p.readInt() & 0xff; + dc.TOA = p.readInt(); + dc.isMpty = (0 != p.readInt()); + dc.isMT = (0 != p.readInt()); + dc.als = p.readInt(); + dc.isVoice = (0 != p.readInt()); + if (isGSM) { + boolean isVideo = (0 != p.readInt()); // Samsung CallDetails + int call_type = p.readInt(); // Samsung CallDetails + int call_domain = p.readInt(); // Samsung CallDetails + String csv = p.readString(); // Samsung CallDetails + } + dc.isVoicePrivacy = (0 != p.readInt()); + dc.number = p.readString(); + int np = p.readInt(); + dc.numberPresentation = DriverCall.presentationFromCLIP(np); + dc.name = p.readString(); + dc.namePresentation = p.readInt(); + int uusInfoPresent = p.readInt(); + if (uusInfoPresent == 1) { + dc.uusInfo = new UUSInfo(); + dc.uusInfo.setType(p.readInt()); + dc.uusInfo.setDcs(p.readInt()); + byte[] userData = p.createByteArray(); + dc.uusInfo.setUserData(userData); + riljLogv(String.format("Incoming UUS : type=%d, dcs=%d, length=%d", + dc.uusInfo.getType(), dc.uusInfo.getDcs(), + dc.uusInfo.getUserData().length)); + riljLogv("Incoming UUS : data (string)=" + + new String(dc.uusInfo.getUserData())); + riljLogv("Incoming UUS : data (hex): " + + IccUtils.bytesToHexString(dc.uusInfo.getUserData())); + } else { + riljLogv("Incoming UUS : NOT present!"); + } + + // Make sure there's a leading + on addresses with a TOA of 145 + dc.number = PhoneNumberUtils.stringFromStringAndTOA(dc.number, dc.TOA); + + response.add(dc); + + if (dc.isVoicePrivacy) { + mVoicePrivacyOnRegistrants.notifyRegistrants(); + riljLog("InCall VoicePrivacy is enabled"); + } else { + mVoicePrivacyOffRegistrants.notifyRegistrants(); + riljLog("InCall VoicePrivacy is disabled"); + } + } + + Collections.sort(response); + + if ((num == 0) && mTestingEmergencyCall.getAndSet(false)) { + if (mEmergencyCallbackModeRegistrant != null) { + riljLog("responseCallList: call ended, testing emergency call," + + " notify ECM Registrants"); + mEmergencyCallbackModeRegistrant.notifyRegistrant(); + } + } + + return response; + } + + @Override + protected Object responseSignalStrength(Parcel p) { + int numInts = 12; + int response[]; + + // Get raw data + response = new int[numInts]; + for (int i = 0; i < numInts; i++) { + response[i] = p.readInt(); + } + + //gsm + response[0] &= 0xff; + + //cdma + response[2] %= 256; + response[4] %= 256; + response[7] &= 0xff; + + return new SignalStrength(response[0], response[1], response[2], response[3], response[4], response[5], response[6], response[7], response[8], response[9], response[10], response[11], true); + } + + @Override + public void setPhoneType(int phoneType){ + super.setPhoneType(phoneType); + isGSM = (phoneType != RILConstants.CDMA_PHONE); + } + + @Override + protected RILRequest + processSolicited (Parcel p, int type) { + int serial, error; + int dataPosition = p.dataPosition(); // save off position within the Parcel + + serial = p.readInt(); + error = p.readInt(); + + RILRequest rr; + + rr = mRequestList.get(serial); + if (rr == null || error != 0 || p.dataAvail() <= 0) { + p.setDataPosition(dataPosition); + return super.processSolicited(p, type); + } + + try { switch (rr.mRequest) { + case RIL_REQUEST_OPERATOR: + String operators[] = (String [])responseStrings(p); + + riljLog("Operator response"); + + if (operators == null || operators.length < 0) { + riljLog("Operators is empty or null"); + } else { + riljLog("Length of operators:" + operators.length); + for (int i = 0; i < operators.length; i++) { + riljLog("Operator[" + i + "]:" + operators[i]); + } + } + + if (!isGSM) { + riljLog("Forcing operator name using build property ro.cdma.home.operator.alpha"); + operators[0] = SystemProperties.get("ro.cdma.home.operator.alpha"); + } + + if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest) + + " " + retToString(rr.mRequest, operators)); + + if (rr.mResult != null) { + AsyncResult.forMessage(rr.mResult, operators, null); + rr.mResult.sendToTarget(); + } + mRequestList.remove(serial); + break; + case RIL_REQUEST_VOICE_REGISTRATION_STATE: + String voiceRegStates[] = (String [])responseStrings(p); + + riljLog("VoiceRegistrationState response"); + + if (voiceRegStates == null || voiceRegStates.length < 0) { + riljLog("VoiceRegStates is empty or null"); + } else { + riljLog("Length of voiceRegStates:" + voiceRegStates.length); + for (int i = 0; i < voiceRegStates.length; i++) { + riljLog("VoiceRegStates[" + i + "]:" + voiceRegStates[i]); + } + } + + if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest) + + " " + retToString(rr.mRequest, voiceRegStates)); + + if (rr.mResult != null) { + AsyncResult.forMessage(rr.mResult, voiceRegStates, null); + rr.mResult.sendToTarget(); + } + mRequestList.remove(serial); + break; + case RIL_REQUEST_DATA_REGISTRATION_STATE: + String dataRegStates[] = (String [])responseStrings(p); + + riljLog("DataRegistrationState response"); + + if (dataRegStates == null || dataRegStates.length < 0) { + riljLog("DataRegStates is empty or null"); + } else { + riljLog("Length of dataRegStates:" + dataRegStates.length); + for (int i = 0; i < dataRegStates.length; i++) { + riljLog("DataRegStates[" + i + "]:" + dataRegStates[i]); + } + } + + if (RILJ_LOGD) riljLog(rr.serialString() + "< " + requestToString(rr.mRequest) + + " " + retToString(rr.mRequest, dataRegStates)); + + if (rr.mResult != null) { + AsyncResult.forMessage(rr.mResult, dataRegStates, null); + rr.mResult.sendToTarget(); + } + mRequestList.remove(serial); + break; + default: + p.setDataPosition(dataPosition); + return super.processSolicited(p, type); + }} catch (Throwable tr) { + // Exceptions here usually mean invalid RIL responses + + Rlog.w(RILJ_LOG_TAG, rr.serialString() + "< " + + requestToString(rr.mRequest) + + " exception, possible invalid RIL response", tr); + + if (rr.mResult != null) { + AsyncResult.forMessage(rr.mResult, null, tr); + rr.mResult.sendToTarget(); + } + return rr; + } + + return rr; + } + + private void + fixNitz(Parcel p) { + int dataPosition = p.dataPosition(); + String nitz = p.readString(); + long nitzReceiveTime = p.readLong(); + + String[] nitzParts = nitz.split(","); + if (nitzParts.length >= 4) { + // 0=date, 1=time+zone, 2=dst, 3(+)=garbage that confuses ServiceStateTracker + nitz = nitzParts[0] + "," + nitzParts[1] + "," + nitzParts[2]; + p.setDataPosition(dataPosition); + p.writeString(nitz); + p.writeLong(nitzReceiveTime); + // The string is shorter now, drop the extra bytes + p.setDataSize(p.dataPosition()); + } + } + + @Override + protected void + processUnsolicited (Parcel p, int type) { + Object ret; + int dataPosition = p.dataPosition(); // save off position within the Parcel + int response = p.readInt(); + + switch(response) { + case RIL_UNSOL_RIL_CONNECTED: + ret = responseInts(p); + setRadioPower(false, null); + setPreferredNetworkType(mPreferredNetworkType, null); + setCdmaSubscriptionSource(mCdmaSubscription, null); + if(mRilVersion >= 8) + setCellInfoListRate(Integer.MAX_VALUE, null); + notifyRegistrantsRilConnectionChanged(((int[])ret)[0]); + break; + case RIL_UNSOL_NITZ_TIME_RECEIVED: + fixNitz(p); + p.setDataPosition(dataPosition); + super.processUnsolicited(p, type); + break; + case RIL_UNSOL_RESPONSE_IMS_NETWORK_STATE_CHANGED: + ret = responseVoid(p); + break; + case RIL_UNSOL_DEVICE_READY_NOTI: + ret = responseVoid(p); + break; + case RIL_UNSOL_AM: + ret = responseString(p); + break; + case RIL_UNSOL_WB_AMR_STATE: + ret = responseInts(p); + break; + case RIL_UNSOL_RESPONSE_HANDOVER: + ret = responseVoid(p); + break; + case RIL_UNSOL_ON_SS_SAMSUNG: + p.setDataPosition(dataPosition); + p.writeInt(RIL_UNSOL_ON_SS); + break; + case RIL_UNSOL_STK_CC_ALPHA_NOTIFY_SAMSUNG: + p.setDataPosition(dataPosition); + p.writeInt(RIL_UNSOL_STK_CC_ALPHA_NOTIFY); + break; + case RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED_SAMSUNG: + p.setDataPosition(dataPosition); + p.writeInt(RIL_UNSOL_UICC_SUBSCRIPTION_STATUS_CHANGED); + break; + default: + // Rewind the Parcel + p.setDataPosition(dataPosition); + + // Forward responses that we are not overriding to the super class + super.processUnsolicited(p, type); + return; + } + } + + @Override + protected void notifyRegistrantsCdmaInfoRec(CdmaInformationRecords infoRec) { + final int response = RIL_UNSOL_CDMA_INFO_REC; + + if (infoRec.record instanceof CdmaSignalInfoRec) { + CdmaSignalInfoRec sir = (CdmaSignalInfoRec) infoRec.record; + if (sir != null + && sir.isPresent + && sir.signalType == SignalToneUtil.IS95_CONST_IR_SIGNAL_IS54B + && sir.alertPitch == SignalToneUtil.IS95_CONST_IR_ALERT_MED + && sir.signal == SignalToneUtil.IS95_CONST_IR_SIG_IS54B_L) { + + Rlog.d(RILJ_LOG_TAG, "Dropping \"" + responseToString(response) + " " + + retToString(response, sir) + + "\" to prevent \"ring of death\" bug."); + return; + } + } + + super.notifyRegistrantsCdmaInfoRec(infoRec); + } + + private void + dialEmergencyCall(String address, int clirMode, Message result) { + RILRequest rr; + + rr = RILRequest.obtain(RIL_REQUEST_DIAL_EMERGENCY, result); + rr.mParcel.writeString(address); + rr.mParcel.writeInt(clirMode); + rr.mParcel.writeInt(0); // CallDetails.call_type + rr.mParcel.writeInt(3); // CallDetails.call_domain + rr.mParcel.writeString(""); // CallDetails.getCsvFromExtra + rr.mParcel.writeInt(0); // Unknown + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest)); + + send(rr); + } + + @Override + public void getRadioCapability(Message response) { + riljLog("getRadioCapability: returning static radio capability"); + if (response != null) { + Object ret = makeStaticRadioCapability(); + AsyncResult.forMessage(response, ret, null); + response.sendToTarget(); + } + } + + protected Object + responseFailCause(Parcel p) { + int numInts; + int response[]; + + numInts = p.readInt(); + response = new int[numInts]; + for (int i = 0 ; i < numInts ; i++) { + response[i] = p.readInt(); + } + LastCallFailCause failCause = new LastCallFailCause(); + failCause.causeCode = response[0]; + if (p.dataAvail() > 0) { + failCause.vendorCause = p.readString(); + } + return failCause; + } + + // This call causes ril to crash the socket, stopping further communication + @Override + public void + getHardwareConfig (Message result) { + riljLog("getHardwareConfig: not supported"); + if (result != null) { + CommandException ex = new CommandException( + CommandException.Error.REQUEST_NOT_SUPPORTED); + AsyncResult.forMessage(result, null, ex); + result.sendToTarget(); + } + } + + @Override + public void setDataAllowed(boolean allowed, Message result) { + if (SystemProperties.get("persist.radio.multisim.config").equals("dsds")) { + int req = 123; + RILRequest rr; + if (allowed) { + req = 116; + rr = RILRequest.obtain(req, result); + } else { + rr = RILRequest.obtain(req, result); + rr.mParcel.writeInt(1); + rr.mParcel.writeInt(allowed ? 1 : 0); + } + + send(rr); + } + } + + @Override + public void startLceService(int reportIntervalMs, boolean pullMode, Message response) { + riljLog("startLceService: not supported"); + if (response != null) { + CommandException ex = new CommandException( + CommandException.Error.REQUEST_NOT_SUPPORTED); + AsyncResult.forMessage(response, null, ex); + response.sendToTarget(); + } + } + + /** + * @hide + */ + public void getModemActivityInfo(Message response) { + riljLog("getModemActivityInfo: not supported"); + if (response != null) { + CommandException ex = new CommandException( + CommandException.Error.REQUEST_NOT_SUPPORTED); + AsyncResult.forMessage(response, null, ex); + response.sendToTarget(); + } + } + + @Override + public void setUiccSubscription(int appIndex, boolean activate, Message result) { + // Note: This RIL request is also valid for SIM and RUIM (ICC card) + RILRequest rr = RILRequest.obtain(115, result); + + if (RILJ_LOGD) riljLog(rr.serialString() + "> " + requestToString(rr.mRequest) + + " appIndex: " + appIndex + " activate: " + activate); + + rr.mParcel.writeInt(mInstanceId); + rr.mParcel.writeInt(appIndex); + rr.mParcel.writeInt(mInstanceId); + rr.mParcel.writeInt(activate ? 1 : 0); + + send(rr); + } +} diff --git a/sepolicy/mediacodec.te b/sepolicy/mediacodec.te new file mode 100644 index 0000000..d0822b0 --- /dev/null +++ b/sepolicy/mediacodec.te @@ -0,0 +1 @@ +allow mediacodec proc:file read; diff --git a/sepolicy/mediaserver.te b/sepolicy/mediaserver.te index 8588ec5..0e4fa36 100644 --- a/sepolicy/mediaserver.te +++ b/sepolicy/mediaserver.te @@ -8,3 +8,5 @@ allow mediaserver sysfs_camera:file { getattr open read }; allow mediaserver camera_device:chr_file rw_file_perms; allow mediaserver audio_device:chr_file rw_file_perms; allow mediaserver system_file:file execmod; + +allow mediaserver system_data_file:sock_file write; diff --git a/sepolicy/mm-qcamerad.te b/sepolicy/mm-qcamerad.te index dd60cb0..b617b0f 100644 --- a/sepolicy/mm-qcamerad.te +++ b/sepolicy/mm-qcamerad.te @@ -10,6 +10,7 @@ allow mm-qcamerad system_data_file:sock_file rw_file_perms; allow mm-qcamerad system_data_file:sock_file rw_file_perms; allow mm-qcamerad system_data_file:dir { add_name remove_name write }; allow mm-qcamerad system_data_file:sock_file { create unlink }; +allow mm-qcamerad system_file:file execmod; allow mm-qcamerad system_server:unix_stream_socket rw_socket_perms; allow mm-qcamerad system_data_file:sock_file { create unlink }; diff --git a/sepolicy/priv_app.te b/sepolicy/priv_app.te new file mode 100644 index 0000000..f83e41f --- /dev/null +++ b/sepolicy/priv_app.te @@ -0,0 +1 @@ +allow priv_app device:dir read; diff --git a/sepolicy/radio.te b/sepolicy/radio.te new file mode 100644 index 0000000..9ba85de --- /dev/null +++ b/sepolicy/radio.te @@ -0,0 +1 @@ +allow radio system_app_data_file:dir getattr; diff --git a/sepolicy/rild.te b/sepolicy/rild.te index eda81e4..a3e2496 100644 --- a/sepolicy/rild.te +++ b/sepolicy/rild.te @@ -5,4 +5,4 @@ allow rild radio_data_file:file r_file_perms; allow rild radio_data_file:lnk_file r_file_perms; allow rild system_app_data_file:dir rw_dir_perms; allow rild system_app_data_file:file create_file_perms; - +allow rild unlabeled:dir search; diff --git a/sepolicy/rmt_storage.te b/sepolicy/rmt_storage.te new file mode 100644 index 0000000..ebf0d84 --- /dev/null +++ b/sepolicy/rmt_storage.te @@ -0,0 +1 @@ +allow rmt_storage self:capability dac_override; diff --git a/sepolicy/sysinit.te b/sepolicy/sysinit.te new file mode 100644 index 0000000..3fca72c --- /dev/null +++ b/sepolicy/sysinit.te @@ -0,0 +1 @@ +allow sysinit proc:file read; diff --git a/sepolicy/system_server.te b/sepolicy/system_server.te index c222a9c..0e5d196 100644 --- a/sepolicy/system_server.te +++ b/sepolicy/system_server.te @@ -5,3 +5,7 @@ allow system_server sysfs_display:file rw_file_perms;; allow system_server sysfs_vibeamp:dir search; allow system_server sysfs_vibeamp:file rw_file_perms; allow system_server wifi_data_file:sock_file unlink; +allow system_server persist_data_file:dir search; +allow system_server system_file:file execmod; +allow system_server persist_file:dir read; +allow system_server unlabeled:file unlink; diff --git a/sepolicy/untrusted_app.te b/sepolicy/untrusted_app.te index d39bd7b..af2e867 100644 --- a/sepolicy/untrusted_app.te +++ b/sepolicy/untrusted_app.te @@ -1,2 +1,9 @@ allow untrusted_app fuse:lnk_file read; +allow untrusted_app debugfs:dir read; +allow untrusted_app proc_sysrq:file getattr; +allow untrusted_app rootfs:dir read; +allow untrusted_app rootfs:file getattr; +allow untrusted_app smd_device:chr_file getattr; +allow untrusted_app sysfs:dir read; allow untrusted_app sysfs:file { getattr open read }; +allow untrusted_app system_data_file:file read; diff --git a/sepolicy/wcnss_service.te b/sepolicy/wcnss_service.te index 0bfa877..be2c72d 100644 --- a/sepolicy/wcnss_service.te +++ b/sepolicy/wcnss_service.te @@ -1,2 +1,3 @@ allow wcnss_service efs_file:dir search; allow wcnss_service wifi_efs_file:file { getattr open read }; +allow wcnss_service wifi_efs_file:dir search; diff --git a/system.prop b/system.prop index 2f94d10..6129b9d 100644 --- a/system.prop +++ b/system.prop @@ -61,7 +61,7 @@ persist.data.qmi.adb_logmask=0 persist.radio.add_power_save=1 rild.libargs=-d /dev/smd0 rild.libpath=/system/lib/libsec-ril.so -ro.telephony.ril_class=SamsungMSM8226RIL +# ro.telephony.ril_class=SamsungMSM8226RIL ro.telephony.ril.config=simactivation ro.use_data_netmgrd=false