static jbyteArray com_android_nfc_NativeNfcSecureElement_doTransceive(JNIEnv *e, jobject o, jint handle, jbyteArray data) { jbyteArray result = NULL; uint8_t* pSendApduBuffer; uint32_t nSendApduBufferLength; uint8_t receivedApduBuffer[RECEIVE_APDU_BUFFER_MAX_LENGTH]; uint32_t nReceivedApduActualLength; LogInformation("NativeNfcSecureElement.doTransceive() with handle %d", handle); pSendApduBuffer = (uint8_t *) e->GetByteArrayElements(data, NULL); nSendApduBufferLength = (uint32_t) e->GetArrayLength(data); W_ERROR error = W7816ExchangeAPDUSync((W_HANDLE) handle, pSendApduBuffer, nSendApduBufferLength, receivedApduBuffer, RECEIVE_APDU_BUFFER_MAX_LENGTH, &nReceivedApduActualLength); if (error != W_SUCCESS) { LogError("NativeNfcSecureElement.doTransceive(): exchange APDU failed: error=0x%X", error); } else { /* Copy results back to Java */ LogInformation("NativeNfcSecureElement.doTransceive(): received APDU reply - %d bytes", nReceivedApduActualLength); result = e->NewByteArray(nReceivedApduActualLength); if(result != NULL) { e->SetByteArrayRegion(result, 0, nReceivedApduActualLength, (jbyte *) receivedApduBuffer); } } e->ReleaseByteArrayElements(data, (jbyte*) pSendApduBuffer, JNI_ABORT); return result; }
static jint com_android_nfc_NativeNfcSecureElement_doOpenSecureElementConnection(JNIEnv *e, jobject o) { LogInformation("NativeNfcSecureElement.doOpenSecureElementConnection()"); W_HANDLE hChannel = 0; W_ERROR error = -1; if (seInitialized == W_FALSE) { getSecureElementList(); seInitialized = W_TRUE; } if (defaultSEId != UNDEFINED) { error = WSEOpenConnectionSync(defaultSEId, W_TRUE, &seConnection); LogInformation("NativeNfcSecureElement.doOpenSecureElementConnection(): opened connection to SE: handle=%d", seConnection); if (error == W_SUCCESS) { error = W7816OpenChannelSync(seConnection, W_7816_CHANNEL_TYPE_RAW, NULL, 0, &hChannel); if (error != W_SUCCESS) { LogError("NativeNfcSecureElement.doOpenSecureElementConnection(): can't open Channel to SE: error=0x%X", error); } }else { LogError("NativeNfcSecureElement.doOpenSecureElementConnection(): can't open connection to SE: error=0x%X", error); } } else { LogWarning("NativeNfcSecureElement.doOpenSecureElementConnection(): default Secure Element is not set"); } LogInformation("openSecureElementConnection - returned hChannel: %d", hChannel); return (jint) hChannel; }
static jint com_opennfc_extension_engine_VirtualTagAdapter_virtualTagCreate(JNIEnv * e, jobject o, jint cardType, jbyteArray identifier, jint tagCapacity, jint virtualTagIndice) { LogInformation(" Jni virtualTagCreate"); W_HANDLE phHandle = 0; uint8_t vtIndice; uint8_t type; uint32_t maxLength; JNIEnv env = *e; vtIndice = virtualTagIndice; type = cardType; maxLength = tagCapacity; uint8_t * uid = (uint8_t *) env->GetByteArrayElements(e, identifier, NULL); uint32_t uidLen = (uint32_t) env->GetArrayLength(e, identifier); if (type == 2) // W_PROP_ISO_14443_4_A { type = W_PROP_NFC_TAG_TYPE_4_A; } else if (type == 4) { // W_PROP_ISO_14443_4_B type = W_PROP_NFC_TAG_TYPE_4_B; } WVirtualTagCreate(type, uid, uidLen, maxLength, &phHandle); env->ReleaseByteArrayElements(e, identifier, (jbyte *) uid, JNI_ABORT); LogInformation("virtualTagCreate jni: handle = %d", phHandle); return (jint) phHandle; }
static void com_opennfc_extension_nfc_api_OpenNFCExtManager_nativeSendData(JNIEnv * e, jobject o, jint extClientId, jbyte cmd, jint reqId, jbyteArray data) { JNIEnv env = *e; bool_t status; tMessageOpenNFC msg; LogInformation("nativeSendData(): ENTER"); msg.header.clientId = extClientId; msg.header.commandId = cmd; msg.header.reqId = reqId; msg.pData = (uint8_t*) env->GetByteArrayElements(e, data, NULL); msg.header.length = (msg.pData == NULL) ? 0 : env->GetArrayLength(e, data); LogInformation("nativeSendData: length=%d, pData=%p", msg.header.length, msg.pData); status = sendOpenNfcExtMessage(&msg); env->ReleaseIntArrayElements(e, data, (jint*) msg.pData, 0); /* pthread_t openNfcExtRcvNotificationsThreadId; pthread_create(&openNfcExtRcvNotificationsThreadId, NULL, testThread, (void*) o); */ // f = e->GetFieldID(c, "mConnectedTechIndex", "I"); }
/* callback function to be called when the notification is received */ static void openNfcExtNotifCallback (tMessageOpenNFC* pMessage) { LogInformation("openNfcExtNotifCallback: ENTER"); char* dump = dumpUnit8Array(pMessage->pData, pMessage->length); LogInformation("openNfcExtNotifCallback: Message: length = %d, data=%s", pMessage->length, dump); free (dump); LogInformation("openNfcExtNotifCallback: EXIT"); }
W_ERROR getSecureElementList() { LogInformation("getSecureElementList"); W_ERROR nError; if ((nError = WNFCControllerGetIntegerProperty(W_NFCC_PROP_SE_NUMBER, &seNumber)) == W_SUCCESS) { LogInformation("getSecureElementList(): seNumber=%d", seNumber); } else { LogError("Can't get Secure Elements number (err=0x%X)", nError); return nError; } if (seNumber > MAX_SE_NUMBER) { LogWarning("Too many Secure Elements (%d), retrieve only %d", seNumber, MAX_SE_NUMBER); seNumber = MAX_SE_NUMBER; } for(uint32_t index = 0; index < seNumber; index++) { W_ERROR seError; if ((seError = WSEGetInfoEx(index, &seInfo[index])) != W_SUCCESS) { nError = seError; break; } else { tWSEInfoEx* pInfo = &seInfo[index]; LogInformation("getSecureElementList(): SE #%d: protocols=0x%X, capabilities=0x%X", pInfo->nSlotIdentifier, pInfo->nSupportedProtocols, pInfo->nCapabilities); if ((pInfo->nCapabilities & W_SE_FLAG_COMMUNICATION) && (defaultSEId == UNDEFINED)) { defaultSEId = index; LogInformation("getSecureElementList(): defaultSEId=%d, capabilities=0x%X", index, pInfo->nCapabilities); } if ((pInfo->nCapabilities & W_SE_FLAG_UICC) && (uiccId == UNDEFINED)) { uiccId = index; LogInformation("getSecureElementList(): uiccId=%d, capabilities=0x%X", index, pInfo->nCapabilities); } } } if (defaultSEId == UNDEFINED) { LogWarning("Default Secure Element can't be selected"); } return nError; }
/* callback function to be called when the notification for Open NFC Extension Manager's reply is received */ void openNfcExtNotifCallback (tMessageOpenNFC* pMessage) { LogInformation("openNfcExtNotifCallback: ENTER"); JNIEnv* e = getJniEnv(); jmethodID method; JNIEnv env = *e; jbyteArray outData = env->NewByteArray(e, pMessage->header.length); if (pMessage->header.length > 0) { env->SetByteArrayRegion(e, outData, 0, pMessage->header.length, (jbyte *) pMessage->pData); } method = env->GetStaticMethodID(e, classManager, "replyCallback", "(II[B)V"); if (method == 0) { LogError("openNfcExtNotifCallback(): can't call replyCallback()"); return; } env->CallStaticVoidMethod(e, classManager, method, pMessage->header.reqId, pMessage->header.errStatus, outData); env->DeleteLocalRef(e, outData); freeJniEnv(); }
void pEventCallback(void *pHandlerParameter, uint32_t nEventCode) { LogInformation(" Jni pEventCallback"); int indice; indice = (int *) pHandlerParameter; cardEmulationEventCallback(indice, nEventCode); }
void pCommandCallback(void *pCallbackParameter, uint32_t nDataLength) { LogInformation(" Jni pCommandCallback"); int indice; indice = (int *) pCallbackParameter; cardEmulationCommandEventCallback(indice); }
void vEventCallback(void *pHandlerParameter, uint32_t nEventCode) { LogInformation(" Jni virtualTag: vEventCallback"); int indice; indice = (int *) pHandlerParameter; virtualTagEventCallback(indice, nEventCode); }
DevId_t DmCreateDevice(char *Name, MCoreDevice_t *Device) { /* Grap lock */ SpinlockAcquire(&GlbDmLock); /* Set name and data */ Device->Name = strdup(Name); Device->Id = GlbDmIdentfier; /* Increase */ GlbDmIdentfier++; /* Release */ SpinlockRelease(&GlbDmLock); /* Add to list */ list_append(GlbDmDeviceList, list_create_node(Device->Id, (void*)Device)); /* Call some broadcast function so systems know a new device is avaiable * depending on the device type */ switch (Device->Type) { /* Give access to timer */ case DeviceTimer: { /* Cast */ MCoreTimerDevice_t *Timer = (MCoreTimerDevice_t*)Device->Data; Timer->ReportMs = TimersApplyMs; } break; /* Give access to input */ case DeviceInput: { /* Cast */ MCoreInputDevice_t *Input = (MCoreInputDevice_t*)Device->Data; Input->ReportEvent = EmCreateEvent; } break; /* Register with Vfs */ case DeviceStorage: { /* Call */ VfsRegisterDisk(Device->Id); } break; /* No special actions */ default: break; } /* Info Log */ LogInformation("DRVM", "New Device: %s", Name); /* Done */ return Device->Id; }
/* callback function to be called when cardEmulation Command happens */ void cardEmulationCommandEventCallback(int indice) { LogInformation("cardEmulationCommandEventCallback: ENTER"); JNIEnv* e = attachJniEnv(); jmethodID method; JNIEnv env = *e; jbyteArray returnData = NULL; method = env->GetMethodID(e, classManager, "getCardEmulationHandle", "(I)I"); if (method == 0) { LogError("getCardEmulationHandle(): can't call getCardEmulationHandle()"); detachJniEnv(); return; } jint handle = (jint) env->CallIntMethod(e, job, method, indice); LogInformation(" getCommandData: indice = %d handle = %d", indice, handle); uint8_t * pDataBuffer = (uint8_t*) malloc(RETURN_MESSAGE_MAX_BUFFER_SIZE); if (pDataBuffer != null) { uint32_t pnActualDataLength = 0; WEmulGetMessageData((W_HANDLE) handle, pDataBuffer, TRANSCEIVE_MAX_BUFFER_SIZE, &pnActualDataLength); returnData = env->NewByteArray(e, pnActualDataLength); if (returnData != NULL) { env->SetByteArrayRegion(e, returnData, 0, pnActualDataLength, (jbyte *) pDataBuffer); } method = env->GetMethodID(e, classManager, "cardEmulCommandCallback", "(I[B)V"); if (method == 0) { LogError("cardEmulationEventCallback(): can't call cardEmulEventCallback()"); free(pDataBuffer); env->DeleteLocalRef(e, returnData); detachJniEnv(); return; } env->CallVoidMethod(e, job, method, indice, returnData); free(pDataBuffer); } env->DeleteLocalRef(e, returnData); detachJniEnv(); }
int semaphore_init(sem_t * semaphore, const char * file, int line) { int status; LogInformation("Initialization of semaphore in %s at %d", file, line); if ((status = sem_init(semaphore, 0, 0)) == -1) { LogError("sem_init() failed in %s at %d (errno=0x%X)", file, line, errno); } return status; }
/** * Launch the test framework * @param nArgc Number of arguments * @param pArgv Arguments give */ int main(int nArgc, char* pArgv[]) { int resultStart; bool_t status; uint8_t data[] = {0x01, 0x02}; tMessageOpenNFC msg; msg.length = 2; msg.pData = &data; msg.clientId = OPEN_NFC_TEST; LogInformation("\n*****************************\n\t Starting Open NFC Wrapper Test Launcher !\n"); registerOpenNfcExtNotificationCallback(OPEN_NFC_TEST, openNfcExtNotifCallback); status = openOpenNfcExtConnection(); LogInformation("called openOpenNfcExtConnection(): status = %d", status); sleep(3); char* dump = dumpUnit8Array(msg.pData, msg.length); LogInformation( "Message: length = %d, data=%s", msg.length, dump); free (dump); status = sendOpenNfcExtMessage(&msg); LogInformation("called sendOpenNfcExtMessage(): status = %d", status); sleep(300); status = closeOpenNfcExtConnection(); LogInformation("called closeOpenNfcExtConnection(): status = %d", status); /* if(nArgc<3) { LogError("Not enough parameter !"); LogError("Usage : %s <TARGET> <CONFIGURATION>", pArgv[0]); LogError(" <TARGET> : Target to reach, use M for Microread and S for Simulator"); LogError(" <CONFIGURATION> : Configuration (IP)"); return -1; } */ return 0; }
static jint com_opennfc_extension_engine_CardEmulationAdapter_sendAnswer(JNIEnv * e, jobject o, jint handle, jbyteArray reponse) { uint32_t result = -1; LogInformation("Jni: sendAnswer "); JNIEnv env = *e; uint8_t * rps = (uint8_t *) env->GetByteArrayElements(e, reponse, NULL); uint32_t rpsLen = (uint32_t) env->GetArrayLength(e, reponse); result = WEmulSendAnswer((W_HANDLE) handle, rps, rpsLen); env->ReleaseByteArrayElements(e, reponse, (jbyte *) rps, JNI_ABORT); return (jint) result; }
/* Initialize Vfs */ void VfsInit(void) { /* Debug */ LogInformation("VFSM", "Initializing"); /* Create lists */ GlbFileSystems = list_create(LIST_SAFE); GlbOpenFiles = list_create(LIST_SAFE); GlbFileSystemId = 0; GlbVfsInitHasRun = 0; }
int semaphore_destroy(sem_t * semaphore, const char * file, int line) { int status; LogInformation("Close semaphore in %s at %d", file, line); if ((status = sem_destroy(semaphore)) == -1) { LogError("sem_destroy() failed in %s at %d (errno=0x%X)", file, line, errno); } return status; }
static jint com_opennfc_extension_engine_SecureElementAdapter_getSecureElementsNumber(JNIEnv * e, jobject o) { int nbSE = 0; W_ERROR error = WNFCControllerGetIntegerProperty(W_NFCC_PROP_SE_NUMBER, &nbSE); LogInformation("getSecureElements(): SE number = %d", nbSE); if (error != W_SUCCESS) { LogError("Can't retrieve the number of Secure Elements (error=0x%X)", error); } return (jint) nbSE; }
static jboolean com_opennfc_extension_engine_CardEmulationAdapter_setCardEmulationMode(JNIEnv * e, jobject o, jboolean enable) { W_ERROR error; if (enable == JNI_TRUE) { WNFCControllerGetRFLock(W_NFCC_STORAGE_VOLATILE, &readerLock, &cardLock); LogInformation("start CardEmulation Mode with readerLock %d cardLock %d", readerLock, cardLock); error = WNFCControllerSetRFLockSync(W_NFCC_STORAGE_VOLATILE, W_TRUE, W_FALSE); error = WNFCControllerSwitchStandbyMode(W_FALSE); } else { error = WNFCControllerSetRFLockSync(W_NFCC_STORAGE_VOLATILE, readerLock, cardLock); LogInformation("shut down CardEmulation mode with readerLock %d", readerLock); LogInformation("shut down CardEmulation mode with cardLock %d", cardLock); error = WNFCControllerSwitchStandbyMode(W_TRUE); } if (error == W_SUCCESS) return JNI_TRUE; return JNI_FALSE; }
/* Register fs */ void VfsInstallFileSystem(MCoreFileSystem_t *Fs) { /* Ready the buffer */ char IdentBuffer[8]; memset(IdentBuffer, 0, 8); /* Copy the storage ident over */ strcpy(IdentBuffer, "St"); itoa(GlbFileSystemId, (IdentBuffer + 2), 10); /* Construct the identifier */ Fs->Identifier = MStringCreate(&IdentBuffer, StrASCII); /* Setup last */ Fs->Lock = MutexCreate(); /* Add to list */ list_append(GlbFileSystems, list_create_node(Fs->DiskId, Fs)); /* Increament */ GlbFileSystemId++; /* Start init? */ if (Fs->Flags & VFS_MAIN_DRIVE && !GlbVfsInitHasRun) { /* Process Request */ MCoreProcessRequest_t *ProcRequest = (MCoreProcessRequest_t*)kmalloc(sizeof(MCoreProcessRequest_t)); /* Print */ LogInformation("VFSM", "Boot Drive Detected, Running Init"); /* Append init path */ MString_t *Path = MStringCreate(Fs->Identifier->Data, StrUTF8); MStringAppendChars(Path, FILESYSTEM_INIT); /* Create Request */ ProcRequest->Type = ProcessSpawn; ProcRequest->Path = Path; ProcRequest->Arguments = NULL; ProcRequest->Cleanup = 1; /* Send */ PmCreateRequest(ProcRequest); /* Set */ GlbVfsInitHasRun = 1; } }
static jboolean com_opennfc_extension_engine_VirtualTagAdapter_writeNdefMessage(JNIEnv * e, jobject o, jbyteArray buf, jint virtualTagHandle) { JNIEnv env = *e; W_HANDLE msg_handle; W_ERROR result = W_ERROR_TAG_WRITE; uint32_t ndefMessageLength = (uint32_t) env->GetArrayLength(e, buf); if (ndefMessageLength == 0) { LogError("VirtualTagAdapter_writeNdefMessage: Nothing to write"); return JNI_FALSE; } uint8_t *buffer = (uint8_t *) env->GetByteArrayElements(e, buf, NULL); LogInformation("do writeNdefMessage"); WNDEFBuildMessage(buffer, ndefMessageLength, &msg_handle); result = WNDEFWriteMessageSync(virtualTagHandle, msg_handle, W_NDEF_ACTION_BIT_FORMAT_NON_NDEF_TAG | W_NDEF_ACTION_BIT_ERASE); LogInformation("VirtualTagAdapter_writeNdefMessage OK with result = %d", result); env->ReleaseByteArrayElements(e, buf, (jbyte *) buffer, JNI_ABORT); return (result == W_SUCCESS ? JNI_TRUE : JNI_FALSE); }
/* Starts the DeviceManager request thread */ void DmStart(void) { /* Debug */ LogInformation("DRVM", "Starting Request Handler"); /* Create the signal & Request queue */ GlbDmEventLock = SemaphoreCreate(0); GlbDmEventQueue = list_create(LIST_SAFE); /* Spawn the thread */ ThreadingCreateThread("Device Event Thread", DmRequestHandler, NULL, 0); /* Is there a boot video? */ if (GlbDmBootVideo != NULL) DmCreateDevice("Boot-Video", GlbDmBootVideo); }
static jboolean com_android_nfc_NativeNfcSecureElement_doDisconnect(JNIEnv *e, jobject o, jint handle) { LogInformation("NativeNfcSecureElement.doDisconnect()"); jboolean status = JNI_TRUE; // Close SE RAW channel handle W_ERROR error = WBasicCloseHandleSafeSync((W_HANDLE) handle); // Close SE connection handle, only one SE connected for the current version error = WBasicCloseHandleSafeSync((W_HANDLE) seConnection); if (error != W_SUCCESS) { LogError("NativeNfcSecureElement.doDisconnect(): can't close SE connection handle: error=0x%X", error); status = JNI_FALSE; } return status; }
/* callback function to be called when virtualTag Event happens */ void virtualTagEventCallback(int indice, int event) { LogInformation("virtualTagEventCallback: ENTER"); JNIEnv* e = attachJniEnv(); jmethodID method; JNIEnv env = *e; method = env->GetMethodID(e, classManager, "virtualTagEventCallback", "(II)V"); if (method == 0) { LogError("virtualTagEventCallback(): can't call virtualTagEventCallback()"); detachJniEnv(); return; } env->CallVoidMethod(e, job, method, indice, event); detachJniEnv(); }
static jintArray com_android_nfc_NativeNfcSecureElement_doGetTechList(JNIEnv *e, jobject o, jint handle) { LogInformation("NativeNfcSecureElement.doGetTechList"); jintArray techList; /* if(handle <= (jint) seNumber) { techList = e->NewIntArray(1); e->SetIntArrayRegion(techList, 0, 1, &SecureElementTech); return techList; } else { LogWarning("NativeNfcSecureElement.doGetUid(): invalid handle=%d", handle); return NULL; } */ LogWarning("NativeNfcSecureElement.doGetTechList(): handle=%d", handle); return NULL; }
static jbyteArray com_android_nfc_NativeNfcSecureElement_doGetUid(JNIEnv *e, jobject o, jint handle) { LogInformation("NativeNfcSecureElement.doGetUid()"); jbyteArray SecureElementUid; /* if(handle <= (jint) seNumber) { SecureElementUid = e->NewByteArray(SecureElementInfo->RemoteDevInfo.Iso14443A_Info.UidLength); e->SetByteArrayRegion(SecureElementUid, 0, SecureElementInfo->RemoteDevInfo.Iso14443A_Info.UidLength,(jbyte *)SecureElementInfo->RemoteDevInfo.Iso14443A_Info.Uid); return SecureElementUid; } else { LogWarning("NativeNfcSecureElement.doGetUid(): invalid handle=%d", handle); return NULL; } */ LogWarning("NativeNfcSecureElement.doGetUid(): handle=%d", handle); return NULL; }
void main() { /* Declare the variables to be used */ int i,j,tempchar; int results[5][100]; char logString[100]; for(i=0;i<5;i++) { for(j=0;j<100;j++) { results[i][j]=0; } } clrscreen(); for(j=0;j<100;j++) { printf("Answer %d:",j + 1); while ((tempchar < 97) || (tempchar > 101)) { tempchar=getch(); if (tempchar = 8) { return; } } results[tempchar - 97][j]++; clrscreen(); } for(j=0;j<100;j++) { strcpy(logString,""); sprintf(logString,"A: %d",results[0][j]); sprintf(logString,"%s|B: %d",logString,results[1][j]); sprintf(logString,"%s|C: %d",logString,results[2][j]); sprintf(logString,"%s|D: %d",logString,results[3][j]); sprintf(logString,"%s|E: %d\n",logString,results[4][j]); printf("%s",logString); LogInformation(logString); } } // End of main()
bool_t getCardLock(){ LogInformation("shut down Virtual Tag mode with cardLock %d", cardLock); return cardLock; }
static jbyteArray com_opennfc_extension_engine_VirtualTagAdapter_readNdefMessage(JNIEnv * e, jobject o, jint ndefType, jint virtualTagHandle) { JNIEnv env = *e; jbyteArray result = NULL; uint32_t messageLength; W_HANDLE hMessage; WNDEFReadMessageSync(virtualTagHandle, (uint8_t) ndefType, null, &hMessage); if (hMessage == W_NULL_HANDLE) { LogError("hMessage is null, readNdefMessage returns null"); return result; } LogInformation("readNdefMessage : virtualTagHandle=%d, hMessage=%d", virtualTagHandle, hMessage); /* * read Ndef Message */ uint32_t nMessageLength; uint32_t nActualMessageLength; uint8_t* pMessage; W_HANDLE hNextMessage; uint32_t offset; uint8_t* writePoint = (uint8_t *) malloc(MAXIMUM_READ_NDEF_BUFFER_SIZE); if (writePoint == null) { LogError("malloc writePoint is null"); return result; } offset = 0; uint8_t* startPoint = writePoint; while (1) { nMessageLength = WNDEFGetMessageLength(hMessage); pMessage = (uint8_t *) malloc(nMessageLength); LogInformation("readNdefMessage : nMessageLength=%d", nMessageLength); if (pMessage == null) { LogError("pMessage is null"); break; } if (WNDEFGetMessageContent(hMessage, pMessage, nMessageLength, &nActualMessageLength) != W_SUCCESS) { free(pMessage); LogError("WNDEFGetMessageContent fails"); break; } offset += nMessageLength; if (offset >= MAXIMUM_READ_NDEF_BUFFER_SIZE) { free(pMessage); offset -= nMessageLength; LogError("Out of max buffer size"); break; } memcpy(writePoint, pMessage, nMessageLength); writePoint += nMessageLength; free(pMessage); hNextMessage = WNDEFGetNextMessage(hMessage); WBasicCloseHandle(hMessage); hMessage = hNextMessage; if (W_NULL_HANDLE == hNextMessage) { LogInformation("readNdefMessage : Tchao"); break; } } // Fin while result = env->NewByteArray(e, offset); if (result != NULL) { env->SetByteArrayRegion(e, result, 0, offset, (jbyte *) startPoint); } free(startPoint); LogInformation("read NdefMessage OK with length = %d", offset); return result; }
/* Loads the RD */ void ModuleMgrInit(MCoreBootDescriptor *BootDescriptor) { /* Get pointers */ MCoreRamDiskHeader_t *RdHeader = (MCoreRamDiskHeader_t*)BootDescriptor->RamDiskAddress; /* Sanity */ if (BootDescriptor->RamDiskAddress == 0 || BootDescriptor->RamDiskSize == 0) return; /* Info */ LogInformation("MDMG", "Initializing"); /* Parse Kernel Exports */ PeLoadKernelExports(BootDescriptor->KernelAddress, BootDescriptor->ExportsAddress); /* Validate Members */ if (RdHeader->Magic != RAMDISK_MAGIC) { /* Error! */ LogFatal("MDMG", "Invalid Magic in Ramdisk - 0x%x", RdHeader->Magic); return; } /* Valid Version? */ if (RdHeader->Version != RAMDISK_VERSION_1) { /* Error! */ LogFatal("MDMG", "Invalid RamDisk Version - 0x%x", RdHeader->Version); return; } /* Allocate list */ GlbModMgrModules = list_create(LIST_NORMAL); /* Save Module-Count */ uint32_t FileCount = RdHeader->FileCount; Addr_t RdPtr = BootDescriptor->RamDiskAddress + sizeof(MCoreRamDiskHeader_t); /* Point to first entry */ MCoreRamDiskFileHeader_t *FilePtr = (MCoreRamDiskFileHeader_t*)RdPtr; /* Iterate */ while (FileCount != 0) { /* We only care about modules */ if (FilePtr->Type == RAMDISK_MODULE) { /* Get a pointer to the module header */ MCoreRamDiskModuleHeader_t *ModuleHeader = (MCoreRamDiskModuleHeader_t*)(BootDescriptor->RamDiskAddress + FilePtr->DataOffset); /* Allocate a new module */ MCoreModule_t *Module = (MCoreModule_t*)kmalloc(sizeof(MCoreModule_t)); /* Set */ Module->Name = MStringCreate(ModuleHeader->ModuleName, StrUTF8); Module->Header = ModuleHeader; Module->Descriptor = NULL; /* Add to list */ list_append(GlbModMgrModules, list_create_node(0, Module)); } /* Next! */ FilePtr++; FileCount--; } /* Info */ LogInformation("MDMG", "Found %i Modules", GlbModMgrModules->length); /* Done! */ GlbModMgrInitialized = 1; }