void otapi_alpext_proc(alp_tmpl* alp, id_tmpl* user_id) {
/// The function app_invoke() will cause the kernel to call ext_systask() as
/// soon as resources are available.
// Start the task only if: Caller is ROOT, ALP Call is Protocol-255, Task is idle
if ( auth_isroot(user_id) \
&& (alp->inrec.id == 0xFF) \
&& (APP_TASK.event == 0) ) {
app_invoke(alp->inrec.cmd); // Initialize Ping Task on supplied channel
alp_load_retval(alp, 1); // Write back 1 (success)
}
}
ot_bool sub_proc_api_irregular(alp_tmpl* alp, id_tmpl* user_id, otapi_icmd* cmd, ot_u8 cmd_limit) {
ot_u16 retval;
ot_u8 rec_cmd = alp->inq->getcursor[3]; // record command
ot_u8 respond = (rec_cmd & 0x80);
ot_u8 lookup_cmd = (rec_cmd & ~0x80) - 1;
alp->inq->getcursor += 4;
/// Do boundary check, and make sure caller is root
if ( (lookup_cmd >= cmd_limit) || (auth_isroot(user_id) == False) )
return False;
/// Lookup and process the irregular command, supplying it from input queue
retval = cmd[lookup_cmd](alp->inq);
/// Write back the twobye retval integer when response is enabled
return alp_load_retval(alp, retval);
}
/** ALP Processor Callback for Starting a Ping <BR>
* ========================================================================<BR>
* "ALP" is the NDEF-based set of low-level API protocols that OpenTag uses.
* ALP messages can come-in over any communication method: wire, wireless,
* telepathy... anything that can transfer a packet payload.
*
* Some ALPs are standardized. Those get handled by OTlib automatically. ALPs
* that are not recognized are sent to this function to be handled. In this
* demo, we are using a very simple ALP, shown below:
*
* ALP Payload Length: 0
* ALP Protocol ID: 255 (FF)
* ALP Protocol Commands: 0-127 (00-7F) corresponding to channel to sniff
*
* The "user_id" parameter corresponds to the Device ID that sent this ALP.
*
* A quickstart guide to the ALP API is available on the Indigresso Wiki.
* http://www.indigresso.com/wiki/doku.php?id=opentag:api:quickstart
*/
void otapi_alpext_proc(alp_tmpl* alp, id_tmpl* user_id) {
/// The function app_invoke() will cause the kernel to call ext_systask() as
/// soon as resources are available.
vlFILE* fp;
ot_uni16 scratch;
ot_u8 channel;
ot_u8 retval;
// Start the task only if: Caller is ROOT, ALP Call is Protocol-255, Task is idle
if ( auth_isroot(user_id) \
&& (alp->inrec.id == 0xFF) \
&& (APP_TASK.event == 0) ) {
/// Make sure channel is spec-legal. If so, set the channel of the
/// first (and only) in the channel list to the specified one, and also
/// set the channel of the hold scan accordingly. By default, the scan
/// is updated every second. The next scan will have these settings.
retval = 0;
channel = alp->inrec.cmd & 0x7F;
if (((channel & 0xF0) <= 0x20) && ((channel & 0x0F) <= 0x0E)) {
fp = ISF_open_su(ISF_ID(channel_configuration));
scratch.ushort = vl_read(fp, 0);
scratch.ubyte[0] = channel;
vl_write(fp, 0, scratch.ushort);
vl_close(fp);
fp = ISF_open_su(ISF_ID(hold_scan_sequence));
scratch.ushort = vl_read(fp, 0);
scratch.ubyte[0] = channel;
vl_write(fp, 0, scratch.ushort);
vl_close(fp);
retval = 1; //success
}
alp_load_retval(alp, retval);
}
}
void otapi_alpext_proc(alp_tmpl* alp, id_tmpl* user_id) {
/// For this example, the directive ID is 0x90 and the commands are 0-3. You
/// can change these values simply by changing the implementation of this
/// function.
///
/// Alternatively, instead of using the User Task (extprocess) you can use the
/// sys.loadapi link to an app function: sys.loadapi = &opmode_goto_gateway;
/// This is a simpler approach, but it can be blocked eternally in some setups.
/// Using the User Task guarantees that your app/applet will run at some point
/// in the future, as soon as the kernel is done with high-priority I/O tasks.
if (alp->inrec.id == 0x90) {
ot_u8 task_cmd = (alp->inrec.cmd & 0x7F);
// Enable our command processing user task (task 0) to run the command
// routine, but only if the cmd is known (0<=cmd<=3)
if (task_cmd > 3) task_cmd = 0;
else app_invoke(++task_cmd);
// Write back success (non-zero).
alp_load_retval(alp, task_cmd);
}
}
