the present invention is implemented using a software called ‘ mrix ’ from intuwave limited . mrix facilitates the rapid develop of networked application software for mobile devices and provides for secure multi - entity access to resources on such devices . an implementation comprises software resident on the different computing devices connected to the network , including mobile device , such as a smartphone , desktop pc and server , with an example configuration shown in fig1 . software components are required on all of the different elements in the network to facilitate rapid application development and deployment . this is illustrated by the following example for developing a networked application on the mobile device that enables a user to make full use of an enterprise crm system for better customer relationships . to do this , software must be developed on the mobile device that can connect to an enterprise server , that implements the crm system and manages all of the customer interactions for the enterprise . the mobile device must be able to connect both over a wide area connection to the server ( such as over gprs ) as well as through a faster local connection through a broadband wireless link through the pc . the limited user interface of the mobile device also means that the mobile device must connect easily with the desktop pc to allow the user to take advantage of the large screen and keyboard of the desktop pc when the user is sitting at his or her desk . the traditional means of developing such an application would be to develop the software on the desktop pc using appropriate development tools , such as an ide , and to run and test the application on an emulator on the desktop pc . once the software is successfully running on the emulator then it can be transferred to the mobile device , where it needs to be debugged again . this approach is often fine for non - networked application as there is little difference between the emulator and pc . however , for networked applications the emulator does not have the range of network connections available on the mobile device so development is much more difficult . this problem is overcome in mrix by having components on the desktop pc ( which term includes windows , macintosh , linux or any other operating system powered computers ) and mobile device that can be executed over the network connection , either locally over a local wireless link , such as bluetooth , or remotely over gprs ( or any other connection to the phone such as sms ). hence , the developer can proceed in a much faster way for development of the networked application as follows : 1 . the developer chooses which of the modular set of mrix pipe processor components will be used for the application . 2 . the developer tests how the chosen pipe processors will be used from the command line . 3 . a simple script can be put together to put these together into a complete application running on the phone , again running remotely from the desktop pc . 4 . connectivity components on the pc , such as mrouter , which may be part of mrix , are used if networked connectivity is required to , or routing through , the desktop pc from the mobile device . see pct // gb2002 / 003923 , the contents of which are incorporated by reference , for more details on mrouter . 5 . connectivity components on the server are used if the server needs to connect to the phone . this is required as the phone &# 39 ; s ip address is not visible to the outside world so cannot be contacted by the server . hence , the relay server is required that is visible by both the phone and back - office server , to enable networked communication to the server . mrix is a wireless software platform designed to significantly reduce the time to market in producing solutions involving smartphones by :— reducing the learning curve and therefore opening up development to a larger community of developers providing network os like facilities allowing smartphones to be treated like shared network components providing critical “ building blocks ” which encapsulate complex smartphone functionality . mrix includes a platform agnostic remote command execution environment for smartphones . a command interpreter interfaces to a smartphone through a set of commands or “ pipe processors ”. these are small stand - alone modules written in c ++ or scripting languages that encapsulate a range of smartphone functionality . device resident mrix pipe processors ( prefixed with “ mr ”) are provided which facilitate the control and management of multiple bearers ( gprs , sms , bluetooth , mms , wifi etc ); device peripheral ( such as barcode readers , pens , printers , gps etc ); other devices and servers ; and network billing . pipe processors can be “ chained ” together to build more functionality . these building blocks allow fast and iterative development of mobile solutions . the use of scripting languages opens up development to a much broader community of developers . mrix is designed around a command interpreter running on a smartphone and a command execution shell running on a remote pc or other suitable platform . pipe processors can be invoked remotely ( like unix commands ) from a desktop pc via m - router ™ or a remote server via a relay . this not only allows development and debugging of an mrix solution to be carried out from the convenience of a desktop pc but also allows smartphone components to be shared at runtime over networks . some pipe processors are mandatory and are considered core to the system . examples include mrevent or mrat which are used to start and stop processes based on events . a set of optional pipe processors are also supplied which can be removed from the runtime , if required , to minimise the memory footprint custom pipe processors can also be built in c ++ or lua script and templates are provided for this . see “ mrix features at a glance ” for more information on components used . monitoring spare parts availability description keeping an accurate inventory of the levels of spare parts carried by a field engineer is difficult . by combining low cost blue - tooth peripherals such as pen barcode readers with the advanced connectivity features of smartphones , mrix enables field service engineers to keep a tab on van stock levels and automatically enquire if missing stock items can be picked up from other vans in the area . mrix solution mrbluetooth is used to easily manage the connectivity between a smartphone and a bluetooth enabled barcode pen . when the engineer needs a part , he / she “ swipes ” the product barcode from a parts catalogue . a persistent inventory of parts is maintained on the device using mrstorage . automatically , the smartphone indicates to the engineer the available stock on the van . if the part is not available , an sms is created via mrmessage and sent to other engineer &# 39 ; s smartphones . using mrwatchfile on the recipient &# 39 ; s smartphones to trigger on receipt of a specific sms message , the inbound sms causes an inventory check to be carried out . if the remote engineer &# 39 ; s phone indicates that the part is available on the van , an sms is automatically sent back to the original engineer . on receipt of the sms , a prompt automatically displays on the smartphone ( mrprompt ) which informs the engineer that the part is available and supplies the phone number of the engineer with that part . the process can be further enhanced to only inquire of stock availability from engineers who are local using mrsim and the current cell - id . components relay , mrbluetooth , mrstorage , mrmessage , used mrwatchfire , mrprompt , mrsim mrix features at a glance need feature benefit pc connectivity m - router ™ provides ip over serial link . allows full mrcmd control of device from connected pc over bluetooth , irda , cable etc . operation over relay connects devices and server processes over remote connection firewall protected networks where devices ( gprs , wifi etc ) are not “ visible ”. allows device on gprs network to be discovered by other devices or services and facilitates “ push ”. security identities users ( or services ) have to supply credentials to access commands on the device . data storage sky drive ( remote ) important data captured at the smartphone mrstorage ( local ) can be sent to an always available virtual storage device on the network or in the device . data stored can be processed at a later time . messaging mrmessage easy to monitor and manage the device &# 39 ; s message centre . event driven mrwatchfire , mrat , trigger actions when certain situations are operation mrevent met . e . g . run script on receipt of specific sms / mms message . also schedule operations to run at specified times . connectivity mrbluetooth , create and manage connections over mrobex , mrtcp , multiple bearers , examine and process data mrthroughput sent and received and measure network performance . send files via obex . phone information mrsysinfo returns device information including available drives , free space , format etc . network mrsim returns network information such as imei , information current cell - id , area and mobile network operator . remote control mrimage , allow device screen to be projected to a mrkeyboard connected pc and the keyboard of the smartphone to be controlled remotely . file manipulation mrfile easily manipulate the smartphone file system . runtime control mrps , mrmr , query , start and stop processes on the mrboot , smartphone ; start applications automatically mrshutdown , on boot and shut down a device . mrlaunch data capture mrprompt capture data from the user on smartphone via pop up dialog box . pim data access mrcontacts , full search , add , edit and delete of mragenda smartphone pim data including contacts , calendar and memos . possible to manipulate vcards , minivcards , uuids , speed dials , groups etc . specifications supported smartphone symbian os v6 . 1 , 7 . 0 , 7 . 0 s operating systems microsoft pocketpc smartphone edition relay , mrcmd macos x , linux , windows me , 2000 , xp home and professional the core mrix system contains a number of elements some of which are deployed on the smartphone : mrcmd : mrcmd consists of two elements , a command interpreter for smartphones and a remote command execution shell . the command interpreter currently runs on symbian . the remote command execution shell runs on windows , mac os x and linux . m - router ®: command - line interface to intuwave &# 39 ; s existing m - router ® product which handles local connection management on symbian os smartphones . m - router ® operates over serial , bluetooth , usb and irda bearers . mrelay : mrelay consists of both a command - line interface to intuwave &# 39 ; s remote relay server and the relay server itself . currently the relay server can be accessed from the smartphone via gprs or via a wan proxied through a local m - router ® link . pipe processors : pipe processors are small self - contained modules that encapsulate smartphone functionality . a small number of pipe processors that manage event handling and file access are in the mrix core . script engine : a powerful and compact ( 60 k ) lua 5 . 0 scripting engine is included on the smartphone to allow a developer to readily combine pipe processor functionality directly using scripts . included with the scripting engine are a number of core mrix scripts that powerfully combine existing pipe processor functionality . mrix reference manual : html pages that explains how to use all the existing core pipe processors . there are also instructions on writing new pipe processors as well as m - router ® and mrcmd functionality . documentation and example scripts detailing is included . we have a range of additional pipe processors that extend the core functionality of the system . these pipe processors can be readily added to an mrix system to enhance its capabilities . mrix technology is directly applicable in a wide range of applications where remote control of a smartphone device is important : testing : mrix enables full automation of system , functional , acceptance , regression and interoperability tests . pim applications : mrix enables rapid development of pc connectivity pim applications through script - accessible toolkits . mrix offers numerous benefits to smartphone manufacturers and phone network operators . speed of development : mrix development is done in rapid iterations by evolving scripts rather than coding against apis . this significantly speeds up the development lifecycle . cost : since mrix functionality is script - based , the cost of development as well as the cost of maintenance and enhancement of functionality is significantly reduced . cross - platform : mrix offers full cross - platform support for smartphones . when combined with a cross - platform toolkit , server applications can be built to run across different pc operating systems . the security in mrix is modelled around real life . in real life everyone , everything operates as an identity . examining a banking example in more detail is useful in understanding the way security works in mrix . the names and scenarios are blatantly contrived but they serve to illustrate important points . imagine an individual “ alice ” ( a ) enters “ bob bank international ” ( b ) and queues for cashier “ charlotte ” ( c ). alice then pays in or withdraws some cash . this appears a simple transaction , but an individual “ eve ” may and try and steal money from alice or the bank . consider the methods eve might use . they might attempt to impersonate alice and withdraw fund from the bank , or to impersonate charlotte at a fake bank , or to in fact get a job at the bank and as charlotte defraud the bank . there may also be brute force attacks where eve attacks alice outside the bank , or attempts to hold up the bank with a gun . consider an analogous scenario where alice ( a ) accesses the contacts on bobs phone ( b ) and uses mrcontacts ( c ) to add or retrieve contacts . consider that “ eve ” may try and view or corrupt the contacts . they may try and impersonate alice and use bobs phone , or give alice a pretend phone so as to get her to enter the contact . they may even try and install software on bobs phone that acts as mrcontacts and thus can behave maliciously . there may also be brute force attacks on alice or on the physical hardware of bob &# 39 ; s phone . while a callous statement , in both cases the physical protection of alice is her own problem and outside the scope of any protection in / of the bank / phone . likewise the physical protection of the bank building / safe and of the physical memory of the phone is a problem under the realm of the architect of the building / chips . as with all security and all things , there is no perfect answer and no total security , just degrees of confidence . this leaves us with a few important points common to both examples that we can try to address . we want to bc able to prove that alice is who she claims to be we want to ensure that the cashier / mrcontacts is trustworthy we want to ensure it is the intended bank / phone and not an imitation we want to ensure that transactions between alice and the cashier / mrcontacts cannot be eavesdropped and later used to commit fraudulent access . we want to ensure that this not to complicated else the bank / phone will not be used . the is also an example where a person who isn &# 39 ; t a customer of the bank / phone wants to do something , maybe change some coins or check a public contact . obviously in this case we don &# 39 ; t need to authenticate the user , we cant since we have no prior relationship . also we want to be able to allow the guest to do some things and not others . with a bank auditing is important , to show when money was deposited or removed and to check who authorised / performed the transactions . likewise on a phone there may be a desire to record which operations are performed , when and by whom , for billing , diagnostics , or purely interest . consider for a moment alice proving who she is . you can just provide her with a pin code or a secret password and ask her to quote this each time she is uses the bank or phone . this relies on eve not guessing the password or over hearing it . with online banking a common solution is to give a longer pin code and to only ask for a subset of digits . by asking for a different subset each time , eve has to eavesdrop more transactions to discover the entire secret . alternatively one could use alice &# 39 ; s signature . but what if eve makes a photo copy of the signature ? in that care its safer to have alice sign something in front of the cashier and then compare it to a trusted copy . using public private key technology its possible for alice to encrypt arbitrary data with her secret key and then give the encrypted data to the phone together with her public key . since only the public key can decrypt the data , the phone can reasonably assume that the encryptor is alice . by generating unique data to encrypt , the phone can ensure eve cannot capture and re - use the signed data for her own nefarious schemes . of course all this guarantees is that alice has the corresponding private key . the bank then recognizes alice on repeated visits if she uses the same signature each time . in order to prove that this signature corresponds to a person in the real world the bank needs some proof of identity such as a driver &# 39 ; s license or a passport . likewise a digital signature allows the phone to know a user is the same user as ‘ last time ’. in order to link this signature to a real world identity it needs to be supported by a certificate from another trusted entry . such a scheme has to rely on at least one trusted root entry . how does alice know she can trust the cashier ? firstly she has to trust that the bank is careful as to who it employs and gives access to its resources . alice has to trust that the bank checks each morning that charlotte the cashier is who she claims to be . alice knows that most bank systems don &# 39 ; t let charlotte see all of alice &# 39 ; s secrets . charlotte sits at a terminal that may display questions to ask alice , and charlotte may enter the answers , but typically charlotte will not see all the secrets , just the subset used to authenticate alice . this means charlotte doesn &# 39 ; t need to be an expert in authentication she just needs to ask the questions on behalf of the banking systems and to enter alice &# 39 ; s responses . back in the land of mrix one doesn &# 39 ; t want to reproduce complex cryptography and authentication code in each module . rather modules such as rshd or mrbluetooth can ask questions on behalf of a trusted security module , pass alice &# 39 ; s responses back to this secure module and if successful obtain a abstract token , an identity . the bank would not wish ever cashier to know all the permissions and information about all its customers . typically after authentication it allows a cashier to view a subset of the information for that customer . the cashier cannot access every scrap of information , just what is relevant to the task at hand , likewise charlotte the cashier cannot access the information or an arbitrary user , just the user that has been authenticated . there may be different ways of authenticating alice , and this step is clearly separate but sequential with actually taking advantage of alice &# 39 ; s identity . in mrix each component can use the core security module to challenge the user and get an abstract identity module . using that module mrcontacts or any module can query the system for per identity policy and permissions . finally the system only loads modules and command that it ‘ trusts ’. this section describes the target security in mrix . it is written in the present tense though gone of what it describes may not yet exist . a separate document describes the current state of affairs . msecure — this single epoc server combines the functionality of mstream / midentity / mrboot and in doing so offers greater security and functionality with less overhead . for example where as it took at least 12 calls to 2 different servers previously to request a pipe processor it now only takes 2 calls . mrix security is based on the concept of identities . identities are an abstract concept similar to user id &# 39 ; s or principles . pipe processors are invoked on behalf of an identity and thus can behave differently according to which identity it is . identities are represented in the system by identity handles ( tokens ) which can be passed between modules and processes if so desired . identity handles can only be created as a result of an authentication process . given an identity a module can query for permissions and other settings for that user . in addition to the identity invoking a module there is also a second identity available to modules , that being the identity that created / authored / signed that module . each pipe processor ( including but not limited to scripts ) can be supplied with a separate meta data file . this file itself is signed and so modifications to the meta data can be detected . the meta data includes a hash of the pipe processor the file corresponds to copyright , version , licence and author contact information permissions and modules required by the pipe processor ( ie dependencies ) permissions embedded in the pipe processor ( ie policy ) the contents of the file is initially created as a text document by the author and then signed / compiled by the txt2mrix utility . mrix provides several types of authentication including private / public key , plain text and hashed authentications . such credentials are stored encrypted on the device memory . the encryption may be further enhanced in some configurations through the collaboration with trusted hardware ( ie a sim card ) rshd challenge the remote peer running mrcmd so as to authenticate the user . the form of the authentication is negotiated between the server and the peer . plaintext username / password — simple but secrets may be in plain sight md5 hash of username / password and challenge — each time an authentication is needed a unique key is used as a challenge . an algorithm is used to generate a hash from this key , and a secret known only to the trusted entities . both ends perform the same has algorithm , if the transmitted result is the same as the expected response then it follows the peer must know the secret . by transmitting the hash the secret need never be revealed over an unsecured link , by using a unique key each time previous responses cannot be used in subsequent fraudulent authentications . public / private keys — on their own public private keys can be used to prove that the peer is a holder of a private key . certificates can be used to link that ownership to a real world identity . by taking a document and creating a hash of it , and then encoding that hash with a private key a document can be signed . changing the document changes the hash and thus invalidates the signature . msecure uses this property to sign files , and consequently allows scripts to be executed with a selected identity without the need to embed plain text credentials in the script itself . msecure provides encrypted storage facilities for each identity it manages . since pipe processors can be signed / authored with identities this means each pipe processor ‘ can ’ have access to its own secure private storage . within that storage msecure offers per identity sub - storage . for example msecure provides storage to the identity of the ‘ mrfile ’ pipe processor . mrfile can store permissions and policy data in this storage such that no other identity can access this data . with that storage space mrfile can store separate data for the identities “ john doe ” and “ anie won ”. mrfile can this check the ‘ settings / permissions ’ for ‘ johndoe ’. if a script is signed with the mrfile identity then it can access this storage . this means scripts can be used as part or administration and configuration for pipe processor permissions and policies . the data that can be stored in this encrypted storage is a hierarchal name value structure . each name value pair can store a different value for each identity . a comparison might be made with a source control system where there are folders and sub files . each file in addition may have various versions . the name value pairs are unicode text . the storage does not support raw binary data . when identities are removed from the system , for example when pipe processors are uninstalled the associated storage can be automatically deleted . the storages are persisted in the file system in an encrypted form . the encryption of these files can be further protected by using keys which themselves are kept in secure hardware . if this is done then even if the file system is subverted and the data transferred to a different device the absence of the secure hardware ( ie a sim card ) means the data cannot be read . with this level of system support the core pipe processors allow fine grain control over their behaviour . for example mrfile allows read / write access control to different areas of the file system . in order to manage the identities and associated data on a device mrix includes a user interface component called mrixconfig . this user interface allows the following addition / removal of ( user ) identities with arbitrary authentication data . addition / removal of scripts and pipe processors ( themselves identities ) granting and revocation of permissions and policies for the above it should come as no surprise that the user must authenticate themselves before they are able to use the user configuration tool . this allows for shared use of a mobile phone for both personal and corporate use . ie if the phone is purchased by an individual they may grant a subset of their permissions to a corporate it identity that can be used to install and remove corporate applications and data . whether the individual can later administer these corporate apps and data is up to the ‘ contract ’ between the individual and the corporation . mrix allows a range of options to be selected . in this case the individual always has the choice of purging such applications and data from their phone if they so whish . alternatively a corporate may own and issue a mobile device to an employee and grant them permissions to install and run personal applications . again while this data is private to the individual the corporate may purge it if they wish — as they were the granter of permissions to the individual in the first place . such sharing of the phone allows an identity to grant and delegate permissions to other entities . typically there might be some financial agreement in place for this sharing but this is outside the scope of mrix at this time . that said the facilities provided by mrix can be used to implement chargeable services . the mrix core may be burnt into rom or installed as an additional component after a phone is purchased . initially mrix uses an identity called ‘ factory default ’. this identity may be used to create additional user identities to administer the phone . such as corporate it department and sony online gaming etc . file locations for installation are as for the mrix core . note however that the identity . ini file needs to be modified for each new pipe processor dll . scripts currently do not have ‘ allow ’ permissions and so all scripts can be invoked by anyone . the behaviour of such invocations is obviously subject to the behaviour of the pipe processors it uses , in turn dependant on the identity used by the script . other that running or examination a script there is no practical way of telling if a script will execute as expected for a given identity . finally any user can install any pipe processor on their phone regardless of licensing on the pipe processor or ownership of the phone . ( ie a phone supplied to an individual by their employee for business use ) mrix is a platform agnostic wireless network operating system . it is designed to allow rapid cross - platform development of a wide range of mobile applications both on and between smartphones , personal computers and servers . it consists of a powerful set of command - line driven tools which can be built upon and combined into sophisticated pc applications using scripting languages . in addition , mrix can be used to script applications that can be executed on the smartphone itself . mrix consists of a number of elements which can be used to run commands over local links ( ir , bluetooth and usb ) as well as via a remote relay ( tcp / ip , gprs ) as illustrated in error ! reference source not found . m - router : bearer connection agent . m - router consists of a number of both pc and smartphone components . it enables communication between a smartphone and a pc over a variety of short - link bearers : irda , bluetooth , usb and serial . relay : the relay , mrelayd ( the ‘ d ’ stands for daemon ) allows remote access from a pc to a smartphone via gprs . the pc and smartphone both connect to the relay in order for communication between them to occur . identity server : all commands are run , whether locally or remotely , on behalf of an “ identify ” ( person or system ). different identities may be configured to run commands with different results . boot server : handles mrix events to be started on smartphone reboot . command interpreter : a command interpreter module , rshd , runs on the smartphone and is normally set up to start up on boot command shell : a command shell , mrcmd , runs on the pc . the shell currently runs on windows but will soon be available on linux and mac os x . programs and scripts can be written for the pc that communicate and interact with mrix components on the smartphone . lua scripting engine : scripts written in lua ( http :// www . lua . org ) can be run on a smartphone . a number of useful scripts , e . g ., smtp and ftp clients , are provided with the release . pipe processors : discrete smartphone modules that can be accessed through the mrix command environment to provide access to a range of smartphone functionality . pc with irda or bluetooth support microsoft windows 2000 or later m - router mrix smartphone ( nokia 7650 , 3650 , 6600 , n - gage , sonyericsson p800 ) this command displays the help for m - router . all commands have a help option that can be invoked via - h or the long form -- help . this command option searches for all the bluetooth devices in the locality . the first four columns listed are an arbitrary ordinal listing number used to represent the device , the uid ( for smartphone devices this will be the imei number — in this example it is only shown for device 8 ), the bluetooth address and the bluetooth friendly name ( assigned by the user of the device ). find your smartphone from the resulting list of devices then connect to the smartphone by typing the following command at the command prompt for example if your smartphone has a bluetooth name of nokia7650 then the command would be you will see the seen of the m - router icon in the system tray turn from red to blue . you may find that for development purposes using the ordinal resulting from the “ search - devices ” is the most convenient . you can connect to a smartphone using a variety of addressing schemes . the “- d ” option takes the form & lt ; schema & gt ;:& lt ; id & gt ;. schema can be one of n , imei , btaddr , btname , any . if not present , schema is assumed to be any . n will match against the listing number next to each device returned by list - devices or search - devices . imei matches the uid field . btaddr matches bluetooth address . btname matches device bt friendly name . any matches all the above . so , it is possible to connect to a device in various ways thus : & gt ; mrouter - c connect - device - d 8 & gt ; mrouter - c connect - device - d imei : xxxxxxxxxxx & gt ; mrouter - c connect - device - d btaddr : xxxxxxxxxx & gt ; mrouter - c connect - device - d sjc xxxxxxxxx where a period stands for the currently connected device or the first connected device if more than one device is currently connected . mrcmd is a pc side program that allows you to run pipe processors and scripts on the smartphone . before running pipe processors and scripts on the smartphone it is necessary to set up the requisite level of security for your mrix setup . this is done by setting the mrcmd environment variable . at present , identity configuration information is stored in the \ system \ mrix \ identity . ini file on the smartphone . a cto identity has been set up in this file with a password of good . you should use this identity for playing with the mrix system . this can be done from the dos command shell as follows : right click on ‘ my computer ’ on your desktop and select ‘ properties ’. select the ‘ advanced ’ tab . click the ‘ environment variables ’ button . click the ‘ new ’ button in the ‘ system variables ’ list . enter ‘ mrcmd ’ into the ‘ variable ’ field and ‘- i cto - a good ’ into the ‘ variable value ’ field . click ok three times to save the change . once security has been set up , you will need to start up the remote shell daemon , rshd , on the smartphone . you should only have to do this once the first time you run mrix on the smartphone . thereafter , rshd will be automatically started at boot using the mrix boot server . to run rshd , you need to open the mrix application on the smartphone and execute the first command in the list box which should be : the mrix application is a simple way of running commands and scripts on the smartphone . to invoke another command from mrix just simply overwrite an existing command line ( and any necessary parameters ). now you are ready to try running an mrix command using mrcmd over an existing mrouter connection . you may try out any of the wide range of existing pipe processors ; mrps and mrfile will be described here . mrcmd tells the smartphone ( in this case denoted by a period which means the currently connected device but you can be explicit and specify the bluetooth name ) to run the mrps pipe processor with the − 1 option . notice that the command is enclosed in double quotes . this command redirects a file ( c :\ mrix \ bin \ default . car ) to the smartphone . the ‘- w ’ option specifies where on the smartphone the file should be written ( c :\ system \ default . car ). lua scripts can also be invoked using mrcmd . to get help on running lua scripts from the command line , type create a script file called test . lua and copy and paste the text between ( and not including ) the chevrons to the file & gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ; #! luarun mrix . write (“ hello , world !\ n ”) -- run the mrprompt pipe processor -- mrix . run runs other scripts and pipe processors and has the form -- mrix . run ( command , command parameters , [ optional input ]) res = mrix . run (“ mrprompt ”, “- t yesno - p \“ need help ?\””) mrix . write (“ result = “.. res ..”\ n ”) & gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ; lua scripts can be run on the smartphone in one of two ways : by streaming a lua script to the smartphone by running a lua script that resides on the smartphone . the script will print , “ hello , world !” at the command line . by this method the script does not have to be resident on the smartphone . the result is the same as running the script by the first method . lua can be invoked interactively as in the following example thus : for help on lua , check out the following resources : http :// www . lua . org , http :// lua - users . org / wiki / tutorialdirectory . review intuwave &# 39 ; s extensions to lua in the mrix documentation . there are two ways to run a lua script on a smartphone independent of interaction with a pc . the first is to invoke it using the mrix application . simply type the name of the script in the cmd field and any parameters for the script in the params field and select run . the second is to have the script run when the smartphone is turned on . to do this you have to setup an event that loads the script into the boot file of the smartphone : this command adds (- a ) a boot command (- e boot ) to the boot file of the smartphone to run a script (- c luascript . lua ) when the smartphone is turned on . the event is given a name (- n runmyscript ) that acts as a handle such that it can be removed from the boot file thus : all mrix smartphone scripts and pipe processors are run , whether locally or remotely , under the permission of an identity . an identity consists of a username , password and a set of permissions governing which scripts and pipe processors may be run under that identity . the identity file , identity . ini , is located in the \ system \ mrix directory on a smartphone . so far we have run commands via mrcmd using the user , cto ( which has full permissions for all commands ). if a smartphone is setup to run a script when it boots then the default identity it will use will be “ guest ” which has minimal permissions . the script will therefore be limited in the mrix commands that may be run . to do anything useful the identity must change so that the script may take on more permissions . edit the lua script file you created earlier . copy and paste the text between ( and not including ) the chevrons to the file . then use mrfile to send the script to the smartphone and run it using the mrix application . in mix select options | run , enter “ test . lua ” into the cmd field ( make sure the params field blank ) and select run . you will be presented with a prompt to which you may select yes or no . & gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ; #! luarun -- save the current identity , in this case , guest old_id = mrix . getcurrentidentity ( ) -- make a new identity handle using the cto username new_id = mrix . makenewidentity (“ cto ”, “ good ”) -- use this newly created identity to run the following commands mrix . setcurrentidentity ( new_id ) mrix . write (“ hello , world !\ n ”) -- run the mrprompt pipe processor -- mrix . run runs other scripts and pipe processors and has the form -- mrix . run ( command , command parameters , [ optional input ]) res = mrix . run (“ mrprompt ”, “- t yesno - p \“ need help ?\””) mrix . write (“ result = “.. res ..”\ n ”); -- restore the saved identity mrix . setcurrentidentity ( old_id ) -- release the new identity to free up resources mrix . releaseidentity ( new_id ) & gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ;& gt ; the mrix v2 kernel runs as a symbian ‘ server ’ in its own process / thread . clients make calls to the kernel via mrixclient . the kernel itself is made of smaller modules . basic primitive objects are contained in a module called mrixkernelobjects such as pipes , bundles , string and links . another module mrixkernelidentity builds on these classes to provide identity / policy services . a third module mrixkerneltasks adds the ability to create and run tasks provided by dlls , exes and scripts . finally mrixkernel implements the actual symbian server and session classes that drive and co - ordinate the afore mentioned modules . all these modules are currently dlls . a small stub executable ( mrixkernelloader ) loads these dlls and runs them in its process space . in a much future versions of the kernel all these modules may need to be combined into a single executable to prevent the individual dlls being subverted . much of the security of the kernel is a result of combining various classes . to some degree the whole picture may only become clear when all the modules are understood , however it should be possible to understand the role each module plays individually . hopefully this will allow maintenance of the various parts with minimal if any impact on other parts ( keeping the exported api &# 39 ; s the same where possible . the class structure of the kernel ( see fig4 ) at first glance may seem complicated but it is built on recurring patterns and layers so that ( hopefully ) it is simpler than expected . a portion of , this class structure is shown at fig5 . with the exception of a utility class ‘ cutil_logger ’ that provides text file logging functionality , most of the classes are derived from or related to an abstract msharedobjectbase class . a default implementation of the msharedobjectbase class is provided by ckern_objectbase . this has a related factory class nested inside it called cmanager . other classes are derived from these classes to provide a repeating implementation pattern . ckern_objectbase provides reference counting methods however when a reference count reaches 0 the object is not deleted immediately , but rather an active object in the manager class asynchronously garbage collects all null objects . there are a few advantages in this delayed deletion . classes such as strings which reach a reference count of zero can be looked up and ‘ rescued ’ and their reference count incremented if they are required before they are actually deleted . since deletions are done asynchronously if a pointer to an object valid at the start of a function it will still be valid at the end of that function even if it is released by some function called during the execution of that function . this was a cause of some access violations in mstream and while it is possible to code such as to avoid such problems ( and this was done in some places ) the code then looks slightly more complicated . this scheme side steps the problem by ensuring it doesn &# 39 ; t happen in the first place . it also simplifys problems with circulare dependencies . when an object is released it releases the objects it references . rather than being deleted immediately ( and thus potentially causing coding problems ) the object is deleted later after this object has fully detached itself and been deleted . calls into the kernel can execute faster since memory release and compaction are handled at idle time rather than in the context of a synchronous client initiated operation . it avoids some calls to the cleanup stack on object creation . traditionally one pushes new objects onto the cleanup stack liberally knowing that they will be deleted if some method leaves . one aspect of the delayed reference counting scheme is that objects are created with reference count of zero . unless something takes ( partial ) ownership of an object then it is later garbage collected . while the cleanup stack and trap harnesses are a great thing they do incur some measurable performance overhead and so they are only used where needed . the factory / child pattern is taken advantages in several derived classes . for example the manager for ckern_string arranges its children in an ordered list and allows lookups on that list — providing a sharable dictionary of strings . one advantage of this is that common strings such as “ c :\ systemlibs \ mrix \ mrfile . dll ” and “ guest ” etc are stored once and shared between interested classes . in another example the ckern_link manager allows all the objects used by a session to be tracked and validated ( more on this later ). some classes in other modules such as ckern_library and ckern_authenticator themselves are further derived from to provide more specialized classes . at present these sub classes ( library types and authenticator ) types are part of the kernel . mechanisms could be added to the kernel to allow external or third party subclasses though this obviously has security implications ( third party code loaded into the kernel memory address space ) some operations provided by classes are by nature asynchronous . an abstract base class msharedasyncrequest is used to encapsulate such operations . a cancelrequest virtual method allows cancelling of such requests . every instance of a msharedobjectbase derived class has a ‘ handle ’ that uniquely identifies that object in the kernel . at present this handle is actually the ‘ this ’ pointer ( since its unique ) but this should not be assumed as it may well change in future versions of the kernel for security reasons . if a handle is known a cmanager can be used to search for an instance with that matching handle . thus we don &# 39 ; t cast handles to pointer only pointers to handles . having said that , ckern_link objects mentioned below delegate to the object that they aggregate for this handle ( ) value . the objects owned by a cmanager derived object can be iterated by using a templated iterator . this steps through all the owned objects and for each attempts to provide the requested interface . the iterator silently steps onto the next object if that interface is not available . there is no casting of handles to pointers . objects may be shared by different parts of the kernel , and thus can be shared by clients of the kernel by reference to handles . this exposure and sharing of objects by their handles is performed by mrixkernel . dll using flags ( access rights bits ) provided by ckern_link objects implemented in mrixkernelobjects . this section briefly explains the purpose and aspects of the primitive classes provided by mrixkernelobjects . pipes are binary byte fifos . a pipe has 2 ends . the ends are a reader end and a writer end . bytes written into the writer end are buffered inside the pipe to a certain amount . these bytes can then be read out of the pipe in the same order in which they were written . the writer can ‘ close ’ the pipe . this means that no more data is allowed to be written into that pipe . bytes can still be read out of the closed pipe until the pipe is empty at which point the reader will return an error ( eof ). as data is written into the pipe a count is kept of the bytes written into it , conceptually this is the length of the pipe . when a pipe is closed a reader can retrieve this value and thus knowing how much it has already read how much data it has left to read . the writer can specify this ‘ pipe length ’ in advance for example if spooling a file of known length . it is then not allowed to write more than that amount of data in total to the pipe . ( at the point at which that ‘ length ’ is reached the pipe is automatically closed ). if the reader requests the length of a pipe before it is unknown then the value − 1 is returned . this pipe length is not the amount of data the implementation of pipe may buffer inside it . the amount a pipe could buffer internally used to be 4k , it is now 256 bytes however clients should not assume any buffering size . reducing the buffering size for pipes means that the memory per pipe ( and effectively the mrix kernel ) is 1 / 16 th of what it was previously . as the buffer size is reduced more ipc calls are needed to transfer the data in smaller chunks and this adds delay . 256 bytes seems to be a reasonable figure that is ‘ fast enough ’ while not eating up ‘ too much memory ’. currently the circular buffers for pipes is allocated from the heap of the kernel , while such buffers are smaller a future improvement would be to use ‘ chunks ’ these are memory allocations provided by symbian taken from a global memory pool rather than the heap of the mrix kernel . the implementation of the class uses msharedasyncrequest objects to read and write data from a circular buffer . an example might make some sense as to how this works . a client might make a request to write 16k of data into the writer end of a pipe . the pipe implementation fills as much of its 256 byte circular buffer with data from the client but does not complete the client call yet . either before or after this time another client may try and read 8k of data from the pipe . the pipe will write as much as it can ( 256 bytes in this case ) to the reading client . but does not complete the client call yet . it then checks if it can refill its circular buffer from any writing clients which in this case it can and another 256 bytes is read from the writing client into the circular buffer . it then writes this out to the reading client , it repeats this loop until either the writer has no more data to transfer or the reader client &# 39 ; s buffer is full . in this case the reader client buffer will fill first and at that point its asynchronous call is completed . it may make another call to read a further 16k of data and eventually the writer data will be consumed . at which point the client asynchronous call is completed . the pipe code basically shuttles data between 2 clients ( processes / threads ). it can do this relatively easily and fast as it does not need to context switch for each 256 byte chunk . context switches are bad ( ie they take time and slow things down ) so avoiding them is usually a good idea . reading clients can request that they read ‘ one or more ’ in which case the pipe object will complete the reading asynchronous call when it has transferred as much data as it can ( ie if the circular buffer has become empty and it has transferred some data to the reader ). clients can cancel requests in which case they are completed immediately . adding requests or removing requests from the reader or writer ends of a pipe trigger an asynchronous ‘ kick ’ of the pipe transfer engine so even if the engine stalls ( which it never does / should ) it will be restarted when the next request is made / cancelled . since pipes are byte streams they cannot transfer unicode strings as is . there is an encoding of unicode text known as utf8 ( a nice feature of which is that western characters are still readable ) and the kernel is able to accept unicode data and convert it to utf8 and then write that into the pipe . it does this in chunks to keep memory overheads down . most programs use strings but these can be for different reasons . some times the strings are programmatic things like filenames or field names , other times they may be user interface messages . sometimes the strings may be 8 bit and other times they may be 16 bit . using 16 bit strings obviously use twice as much memory as 8 bit strings and so they should be used appropriately . all that said strings are useful things and often they are passed in and out of the kernel . in many cases a string may be heavily re - used . for example strings like “ mrstorage ” and “- list thing - option something .” may be used repeatedly . if the kernel kept duplicates of such strings internally it could soon run out of memory . to reduce the amount of memory required the kernel converts strings to pointers to shared string objects . the cmanager class for ckern_string orders all strings in an array . strings are searched for using a binary chop technique so if there are say 1024 strings inside the kernel it only takes 10 string comparisons worse case scenario to find the matching string . once this is done string objects be compared ( case sensitively ) by comparing the 32 bit pointer to the object . this is fast . strings can be ( and are often ) returned to clients by specifying the string ‘ handle ’. the client can then fetch the contents or enquire if they wish as to the length of the contents . the kernel converts unicode strings to utf8 equivalents so a client may request data in either format . passing a string across thread boundaries has ‘ some ’ overhead over and above passing a handle in a ipc request . thus a client can speed itself up by passing string handles instead of strings , however it may do this at the expense of source code readability . “ bundles are poor misunderstood creatures . give them a chance and thy will be nice to you at christmas .” bundles are a data structure heavily reused used inside the kernel to provide name value pair lists . internally a list is kept of string object pairs . there can be multiple entries in the list with the same value . methods exist to add / replace / remove values based on a string key value . keys are case sensitive . each pair has a 32 bit flag word associated with it . this is used by mrixkernel to control access to clients . ( more on this later ). bundles can be shared between clients and can be watched for changes . that is a client can make an asynchronous request to ‘ watch ’ a bundle . when that bundle is changed ( values changed , items deleted , removed ) then all clients watching that bundle are signalled . the client can then resubmit their watch request and query the bundle for values . in that order to avoid race conditions . ckern_link objects contain pointers to other objects . they expose a 32 bit flag word and aggregate the object they point to . the ckern_link implementation overrides handle ( ) and getextensioninterface ( ) to delegate to the aggregated object each client session ( later described ) has an associated ckern_link :: cmanager instance that owns all the ‘ links ’ used by that session . when a session passed in a handle to an object it is validated against the list of objects ‘ known ’ to that session . in reality this checks they are in the cmanager instance for that session . at the same time the type and access rights ( i . e . the 32 bit flag word ) are checked for the operation the client is requesting . when a session is released so are all the links owned by that session ( via the cmanager object ). a session may have multiple reference counts on a link but this only equates to one reference count on the aggregated object . conceptually all actions are done by an identity and act on a resource owned by ( usually another ) identity . an identity might be a human being , a remote automated process , an application , a authenticated script . an identity has some unique name that can be used programmatically to distinguish an identity . an identity may also have other human readable names or descriptions , but essentially an identity is a named ‘ actor ’. when an identity is referenced there is always a degree of certainty / uncertainty that the identity is really the identity claimed to be . in real life how can a person prove that they are who they claim to be ? when an identity acts on another identity &# 39 ; s resources there is some policy as to what is permitted and how things should behave . in the kernel the identity owning the resource is called the context identity . thus an identity such as cto may act on resources in the context of mrfile . unless a client explicitly sets its context then a shared global context is used . each library ( explained below ) has an identity , currently this identity is autogenerated based on the name of the library , but in the future this identity might better be obtained as a result of signing the library with a digital signature . there are some special ‘ stock object ’ identities that can be requested . guest — an identity used by default for un negotiated external peers defaulltuseridentity — an identity used by user interfaces and other ‘ local ’ modules that has ‘ full ’ permission . in the future it is possible that this identity will be come a ( changeable ) alias for another identity . it is also likely that in the future the default user identity may not have complete admin rights to the device , but in this version it does . it is also possible that applications and code requesting and using this identity may need to be signed or authenticate themselves via some pin code entry . ( this has obvious user interface considerations ) sharedglobalcontext — this is the context shared by all scripts and all ‘ mr ’ libraries unless they explicitly specify another context to use . one can imagine a matrix of separate policy / permission stores , as shown in fig6 . within each store are name value pairs ( implemented currently as bundles ) however there is nothing to stop such policy stores from being stored as expressions or other binary data . what is important is to recognize that there are such logical policy / permission stores / databases . though not shown in fig6 , any identity can appear on either axis . the policy for a given pair of identity and context may be null . in the implementation of this kernel the policy consists of name value pairs but again this might change / evolve ( if needed ) in the kernel the ckern_identity class encapsulates a named identity and the degree of confidence that the identity is genuine . there are no policies or permissions owned or contained within that class . rather the cmanager class can be querried for such information . remember though the identity manager is itself a resource and thus whether or not it actually allows read or write permissions to identity data depends on the identity of the person asking for this data . ie the following situations arise . requesting identity a wants to know what some setting for identity b is in the context of identity c requesting identity a wants to modify the setting for identity b in the context of identity c clients can set the context identity (‘ c ’ above ) and ( should ) be able to set the requesting identity (‘ a ’ above ). only the defaultuseridentity is allowed to request changes to policies . the defaultuseridentity is allowed to run any task / library currently all the ‘ mr ’ libraries do not set the context to be their own identity and so default to the globalsharedcontext identity . the downside of this is that the names of settings for say ‘ mrfile ’ cannot conflict with the settings of say ‘ mrcontacts ’. in the future removing an identity ( such as a user or a library ) might also delete the policies involving that identity ( else a device might fill up over time with old unused policies ) in the current kernel the policy information is held in memory as a bundle and read in once from a text file identity . ini at startup , it is ( given the rearchitecting ) possible for code to be trivially added to save and restore this data from a binary file . in the future such policy data could be stored in a symbian database . in a future version of the kernel a portion of this policy data might even be stored in a sim ( smart card ) identity objects can be obtained by name , however ideally they are obtained as a result of some authentication process . the actual mechanism for authenticating a user is independent of the identity itself and how it is used . the ckern_authenticator class and its derived classes can be used with a sequence of challenges and responses to negotiate a peer identity . the method of performing an authentication be it plain text or md5 hash or certificate / signature challenge is independent of how the challenges and responses are transferred . in some cases there may be no challenge , for example in the plain text authentication as used by rshd there is a challenge that is zero bytes long . having the authenticators inside the kernel mean that can access privileged identity data not available outside of the kernel ( ie passwords ). in some future versions of the kernel the authenticators might use the sim ( smart card ) to perform some aspect of the authentication . currently the only implemented authenticator is a plain text username password authenticator . obviously negotiations may be incoming , outgoing or symmetric . when creating an authenticator one can specify the local identity to present to the peer . and after a ( successful ) negotiation a ckern_identity object representing the peer ( which includes a confidence level ) is obtainable from the authenticator object . this module builds on previous modules and classes to allow the execution of tasks . these tasks are executed inside libraries ( historically called pipe processors ). these libraries may be implemented in arrange of ways from polymorphic dlls to executables to scripts . fig7 illustrates it . it contains a number of properties ( implemented internally as a bundle ) including an identity , input and output pipes and input and output environments . a task also has at least one library and command line pair associated with it . in the case of a script there may be more than one pair . for example a task might have the pair “ myscript . lua ” and “- run thing ” but it also has the pair “ lua5 . exe ” and “ myscript . lua - run thing ”. ( in fact the library &# 39 ; s are pointers to ckern_library instances so a task has access to the identities of the libraries it is executing within as well as the identity it is executed by . a client creates a task at which point various system resources are allocated . then the task is started . internally this actually marks the task object as startable ; at some point a library will service this task and stop / complete the task with some exit code . the client that created the task may asynchronously wait for the task to start and or exit . when executing a task the identity that is passed in to execute as must be one of a stock identity an identity retrieved inside a library for itself an authenticated identity ie you cant just claim to be the cto identity , when running a task you have to prove it . ( even if by a known password ) a library has a queue of tasks ( implemented as a ckern_task :: cmanager ). depending on the implementation of the derived class , the library will execute code in process or out of process which processes that task . in the case of polymorphic dlls this involves loading that dll in a worker thread . the polymorphic dll requests tasks from the kernel . the kernel associates the worker thread with the library that created it and passes it tasks to execute when requested . if the thread dies unexpectedly any tasks running in that thread are marked as ‘ stopped ’. if the thread dies before a task is started then an unrun task is marked as stopped , this means if a bad library constantly leaves in its constructor then successive tasks will be marked as stopped ( with their result codes being set to the exit code of the thread ). if it did not do this then it might be able ( as it did in a previous version of the kernel ) be possible for the kernel to get stuck in a fast loop constantly trying to load a library and failing . in the case of executables , currently the derived library class creates an active object for each running task . that active object starts an instance of that executable . the executable makes requests to the kernel for its ‘ task ’ and the kernel matches up the client thread / process to the correct library object and active object . if the executable exits without setting the task as completed / stopped then the active object detects this fact and sets the task as completed with the exit code of that executable . scripts are handled by their libraries internally delegating the execution to another library which in turn may delegate again until it is handled by a library or an error occurs . finally there is an as yet unused library class which runs inside the kernel — it provides a hard coded / built in command mrixkernelcmd that can be used to administer identities and permissions . it could have been written as an external command but then it would have been necessary to expose internbal interfaces used by this library . mrixkernelcmd is currently unfinished / untested but it should be trivial to complete at which point the user will be able to administer permissions and policies in a secure way . all libraries appear to behave the same to clients . each library has an associate identity , currently this identity is auto generated based on the library name , however in the future this identity might be supplied as a result of signing the library binary with some certificate . each library also has an ‘ info ’ bundle associated with it . currently this bundle is empty , but in the future it might have auto generated data . alternatively in the future this bundle might be securely populated by supplying some meta data file with a library . such library data ‘ might ’ in the future include copyright version resource strings licence information author / credentials for library execution url to get updates from this is the module that pulls everything together to create the kernel ; it is shown in fig8 . when the module loads it creates a cserver derived class . clients can then request a csession derived class . note that because of the changes in symbian ipc api &# 39 ; s various mechanisms of ipc are abstracted . for example to get the second argument of a message one can use the function int32 ( amessage , 2 ) etc . this moves the conditional compilation of code to a single part of the module . ckern_string : cmanager — this is the ‘ dictionary ’ of all strings shared inside the kernel . ckern_bundle :: cmanager and ckern_pipe :: cmanager are used as factories when clients need bundles ore pipes created . ckern_identity :: cmanager acts as a factory for identity objects and also as the object that is queried for policies for those identities . ckern_authenticator :: cmanager creates authenticator objects of the requested type . the manager is initialised with a reference to the identity manager so that it can access password information and get and ‘ return ’ identities . at server construction these managers are used to create several stock objects ( ie guest identity , null pipes etc ) each client creates at least one session derived class . the cmrixkernelsession class handles requests from the client . each session object owns an instance of a ckern_link :: cmanager class . as objects are created and handle reference returned to the client a link object is added ( or reused ) that includes the permissions granted to the use of that link . when a client makes a request and passes in a handle value the session object uses the link manager to validate that handle . it also checks that the link has the right flags ( bits ) set for the requested operation . if the request is asynchronous then it creates an instance of ( derived from ) to handle that request . for example . . . case eopwritepipe : { ilinks −& gt ; logline8 ( null ,“ writepipe ”); ckern_pipe :: cwriter ckern_link * link = getobjectl ( amessage , 0 , ckern_pipe :: cwriter :: etypeuid ,( tany **)& amp ; pwriter , mrix :: k canwrite ); cmrixkernelasyncrequest * req = newrequestlc ( eopwritepipe , amessage , 3 , length ( amessage , 3 )); req −& gt ; addlinkl ( link ); pwriter −& gt ; queuewritel ( req , length ( amessage , 3 ), int32 ( amessage , 1 )); cleanupstack :: popanddestroy ( );// req now owned by writer break ; } logs the function being called , gets the object matching the handle passed in the 0 th parameter of the message , checks that it is of type ckern_pipe :: cwriter and that the link for that object owned by this session includes the mrix :: kcanwrite flag . if any condition is not satisfied the method leaves with kerraccessdenied . creates a request object that will use the client buffer identified by the 3 rd argument of the message associates the link with that request and then calls the method on the writer object that will complete asynchronously destroys the reference this code was holding on the cleanup stack since the writer has taken a reference count and now ‘ owns ’ that request as mentioned each session maintains a list of known objects ( via link objects ) and has permission flags for these objects . other than creating objects , clients can also obtain handles to objects if they are explicitly shared by another client . for example if client a has a handle to a pipe , client b cannot use that handle value until client a explicitly shares that value to client b by specifying its session id . ( each client session has a unique id ). also passing an object into a task or a bundle means that if the task handle is transferred to another client ( as part of running a task ) then the rights to the objects contained in that task are also transferred . the mrix kernel does include some powerful debugging logging — possibly too powerful and so it is only compiled into the debug kernel by default . by creating a directory called c :\ logs \ mrixkernel periodically the kernel will domp out all the objects it has in memory including binary pipe data and otherwise secure data . ie its ok for now for debugging inside intawave on an emulator but don &# 39 ; t ever let that code out into the big wide world as it defeats the point of kernel security . also in the debug build components log as a result of base classes : for example for mrfile if one creates a directory called c :\ logs \ mrfile then each client instance will log all calls made , the results and all data transferred . the following is an example . this is a lot of debugging but a full dump of all the clients interaction with the kernel — it is more useful for debugging the kernel but internally we might also use it when ‘ mr ’ libraries need debugging . this class which exposes the client interface of the kernel is best described in a separate document aimed at users of mrix . it attempts to connect to the kernel , where necessary starting it ( using mrixkernelloader . exe on a device ) and then provides various functions that the user can use to access a range or mrix functions .