CN1701586A - 灵活协议堆栈 - Google Patents

Abstract

本发明涉及协议堆栈及协议堆栈内的协议层，尤其涉及诸如移动电话，膝上计算机及基站的通信终端，但不限于此。本发明提供一种提供用于在处理设备中处理信号的通信协议的方法，该处理设备具有处理器和存储器，该协议由多个协议层定义；该方法包括：加载软件模块到存储器中，该模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于该通用函数的通用函数指针；加载函数映射对象到存储器中，该对象包括对应于通用函数的设备特定函数指针，以便把该通用函数映射到一或多个设备特定函数；基于映射的设备特定函数执行该模块，以便基于该协议层处理所接收信号。

Description

灵活协议堆栈

技术领域

本发明涉及协议堆栈及协议堆栈内的协议层，尤其涉及诸如移动电话，膝上计算机及基站的通信终端，但不限于此。

背景技术

诸如移动电话，膝上计算机及基站的通信设备越来越需要支持具有不同结构的多协议堆栈以允许支持多个无线接入网络标准(同时潜在)，其潜在地支持不同可选特性。例如，膝上计算机可能需要支持无线局域网，GSM或UMTS以及蓝牙上的安全和非安全因特网访问。除链路层上的加密之外被提供为IP协议堆栈内VPN特性的一部分的安全性，被提供为协议堆栈内的不同选项。然而，重要的是非加密分组不被传送到其它非安全性(或低安全性)堆栈。因此，需要在安全框架上提供支持这些不同通信标准的协议堆栈。理想地，这些协议堆栈应当可重构，以允许通过下载新协议软件模块来支持新通信标准或选项，和对现有标准的扩展。另外，通信设备越来越需要能够高效使用不充足电池和射频资源。

因此，需要能够安装通信软件以允许新空中接口技术和可选特性，和对那些技术的扩展，包含附加功能，诸如增强安全性，性能或功耗优化。

通常，协议堆栈的重新配置需要进行协议堆栈软件的模块化(modularisation)，使得层之间的接口不动态变化，并且是明确定义的。协议堆栈和网络接口驱动软件框架存在于许多操作系统中，以检查协议(或驱动程序)模块符合这些接口定义的正确版本，并且接着使用执行环境(操作系统)特定机构把模块安装到系统中。也可以进行测量以验证软件，并且对由协议软件执行的功能实施限制。然而，这些限制通常不考虑上述协议堆栈方案的上下文，这些方案根据支持的服务类型可以对安全性(执行环境)保护措施和操作具有不同要求。并且，这些现有方案不考虑使用多个执行环境实现协议堆栈方案。

通常，移动通信设备的协议堆栈由单个厂商提供。将来，终端设备将需要更加灵活的协议堆栈以支持不同通信技术，并且多个厂商可以参与协议堆栈解决方案。这在可能需要支持具有许多可选特性的若干标准的无线终端中尤其重要。因此，允许协议堆栈的增量更新是非常吸引人的。

协议堆栈由一组层构成，其中每个层可以被视作对所接收的分组或消息执行一系列预定步骤(对应于协议)的软件进程，并且与某个协议实现相关。多个逻辑协议堆栈可以在指定系统中被实例化，例如使用多线程，以同时支持相同基本类型的多个传输类或网络接口。相同协议堆栈的多个逻辑实例通常通过对所有这些逻辑协议堆栈实例使用单个软件(协议堆栈配置)方案来实现。然而，这限制了对不同逻辑实例提供不同安全性以及执行环境优化的灵活性。

如果所有模块根据所需时间性(timeliness)和使用的协议定义成功交互，则仅实现协议堆栈的期望特性。当多数协议依赖不同设备上协议堆栈之间的交互以建立和维护通信连接时，这还将取决于多个设备上的协议堆栈实现。允许软件层的动态插入替换或修改的灵活协议堆栈总是易受欺骗软件(可以是恶意的，或仅是运转不良的)的攻击，这些软件通过不服从协议定义，发送分组到错误接收方，破坏分组，形成不正确或无效分组，或截取和传送分组以故意窃听(eavesdrop)或获得对安全连接的访问，或简单停转(挂起)，能够影响协议堆栈的总体操作或安全性。

这个问题现在的解决办法是使用操作系统特定机构约束协议软件的功能，以最小化欺骗行为的影响，并且允许检测和清除违规模块。

WO 02/28052公开了具有可调整协议的无线网络接口，所述协议使用参数定义可编程协议堆栈行为。这允许通过使用不同参数进行限量的重新配置。然而不允许动态插入新协议软件模块或层。使用参数定义可编程协议堆栈行为的可调整协议具有更加可预测的行为，因为仅可以进行限量的重新配置。它们提供的灵活性不及允许动态插入新协议软件模块的协议堆栈。

US 5751972公开了运行期间动态配置计算机以使用网络上的不同协议建立数据传送路径。通过使用操作系统特定链接机构，实现协议堆栈的组成(composition)。这限制了协议堆栈的灵活性，即每个协议堆栈模块必须符合特定操作系统相关接口定义。并且，只有有限范围的协议模块可以用来保证层之间的交互是明确定义的，以便堆栈会成功操作。

WO 01/88707公开了灵活协议堆栈结构，其在协议堆栈的每个层之间使用活动编程接口层，该堆栈在协议层上面和下面之间提供灵活链路，使得链路在运行时刻可以变化。然而，这些附加中间层增加了堆栈的复杂性，并且如果需要实现混合执行环境，则会严重降低其性能。并且，软件模块的链接以特定于执行环境和编程语言的方式(Java虚拟机)进行，并且为利用Java中的动态类加载概念而进行优化，以允许协议堆栈的动态重新配置。

发明内容

概括地讲，在一个方面，本发明提供一种灵活协议堆栈，其对用于协议堆栈软件层之间的交互的特定于执行环境和/或编程语言的特性进行抽象，因而允许不同软件层在不同执行环境中执行，并且用不同编程语言编写。这通过以下方式来实现，即实现为工作存储器中的代码模块的层传递在信号内，或作为模块入口点函数参数的一组执行环境函数指针，以允许模块自身能够发送信号到其它模块，而无需直接执行不同模块(协议层)，或模块和操作系统之间的链接。这与使操作系统“了解”每个模块的格式的方式相反，该方式需要模块的非常具体的格式以能够被链接。因而各层是“语言无关”的，并且能够使用由执行环境函数指针提供的公共操作系统函数彼此交互。

针对说明书的目的，术语协议堆栈层或软件层是指功能实体，其能够实现为载入到工作存储器并且由执行环境执行或“运行”的代码块或模块，并且其基于预定步骤集合(对应于协议)处理传入信号或分组。该层输出已经基于这个协议进行处理的信号或分组。协议堆栈中层的概念是本领域技术人员所知的，OSI标准给出所述概念的最优例子，该标准为支持此概念根据其角色定义了通信协议堆栈内的软件层。

模块被定义成在诸如包含工作存储器，相关处理器及操作系统的硬件平台的执行环境(以及可选的虚拟机环境)中编译或可执行的程序代码块(特别是对象或执行代码)。在这个说明书中，模块将通常对应于协议堆栈中的功能层。因而，模块将基于与相应层相关的协议对传入信号执行一或多个预定步骤或处理。

逻辑层实例(L.L.I)是层软件(模块)的逻辑实例，例如对应于单线程。对应于相同层软件的多个LLI是可实现的，例如使用具有相关代码模块的多个线程。在本发明中可以不同地配置(及优化)每个LLI。

在一个实施例中，函数指针包括操作系统函数表，其中模块可以调用该表以执行诸如“create_new_LLI”的函数及其它操作指定函数，以便与其它模块或层及诸如存储器内分配和访问信号的数据交互。

在另一个实施例中，使用虚拟操作系统函数表，该函数表的每个函数映射到若干不同执行环境(操作系统)中的相应函数。因而，通过使用虚拟操作系统函数表，软件层和模块可以是操作系统或执行环境无关的，以及语言无关的。

具体在一个方面，本发明提供一种灵活协议堆栈，包括若干软件层，每个层包括绑定消息处理程序，用于在运行时刻接收绑定消息以确定与哪个其它堆栈层交互，使得该堆栈动态可配置(并且通过再次使用绑定消息重新绑定而可重新配置)。因而，对一个层的绑定命令指示该一个层应当将其输出传送到的另一层。以编程语言无关，最好是执行环境无关的方式支持先前提到的交互，使得层之间接口能够以不如先前严格的方式重新定义。这独立地支持层软件的动态升级(例如不需要公共层接口定义的升级)，并且支持多个厂商的协议堆栈的提供。

这个方案避免了在一些已知结构中使用的每个协议堆栈层之间特定于语言或执行环境的中间接口层的必要性。接口层的限制在于，函数调用约定(参数传递机制)和参数语法必须被明确定义，并且被所有软件模块正确理解和实现。因为这些机制普遍依赖于操作系统和编程语言，并且甚至也依赖于编译器，因此限制了这种解决方案在异构环境中的灵活性。因此，本发明还允许使用用不同语言编写和/或在异构处理环境中操作的软件层。

具体在另一方面，提供了一种提供用于在处理设备中处理信号的通信协议的方法，该处理设备具有处理器和存储器，该协议由多个协议层定义；该方法包括：加载软件模块到存储器中，该模块被设置成基于对应于层之一的一组通用函数(generic function)接收和处理信号，该模块在函数映射对象中包括对应于该通用函数的通用函数指针；加载函数映射对象到存储器中，该对象包括对应于通用函数的设备特定函数指针，以便把该通用函数映射到一或多个设备特定函数；基于映射的设备特定函数执行该模块，以便基于该协议层处理所接收信号。

最好该模块被设置成与其它模块交换对应于信号的协议消息，所述其它模块被设置成基于对应于其它层的一组通用函数处理信号。

最好该方法还包括加载其它软件模块到存储器中，其它模块在函数映射对象中包括对应于通用函数的通用函数指针；针对每个其它模块加载函数映射对象到存储器中，该对象包括对应于通用函数的设备特定函数指针，以便把该通用函数映射到一或多个设备特定函数；基于所映射的设备特定函数执行该其它模块，以便基于该协议层处理所接收信号。

最好该方法还包括接收包括另一所述模块的标识符的绑定消息的所述或每个加载的软件模块，第一模块被设置成与由所述绑定消息标识的其它模块交换协议消息。

最好该模块具有用于处理协议消息的不同配置选项。

最好该绑定消息包括用于确定在模块执行中实现哪个配置选项的标识符。

最好该协议消息，绑定消息和通用函数指针具有公共通用格式。

最好该方法还包括：加载第二软件模块到存储器中，该第二模块被设置成基于对应于层中的第二层的一组通用函数接收和处理信号，该第二模块在第二函数映射对象中包括对应于通用函数的通用函数指针；加载第二函数映射对象到存储器中，该对象包括对应于通用函数的第二设备特定函数指针，以便把该通用函数映射到一或多个第二设备特定函数；基于所映射的第二设备特定函数执行该第二模块，以便基于所述协议层处理所接收信号；使得所述第一和第二模块在不同执行或特定于设备的环境中被执行。

最好该模块是语言无关的。

最好该方法还包括提供高级软件语言代码，用于基于对应于所述层的所述一组通用函数处理该信号；以及将该代码编译成语言无关的软件模块。

最好该方法还包括基于所述映射的设备特定函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供该模块的2个逻辑实例。

最好该方法还包括：加载第二函数映射对象到存储器中，该对象包括对应于通用函数的第二设备特定函数指针，以便把该通用函数映射到一或多个第二设备特定函数；以及除所述第一执行过程之外，基于所述映射的第二设备特定函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供所述模块的2个逻辑实例，使得该模块的2个实例基于不同函数映射对象被执行。

最好2个执行过程在不同执行或特定于设备的环境中执行。

最好该方法还包括接收包括另一模块的标识符的第二绑定消息的被加载软件模块的第二实例，第一模块的第二实例被设置成与由第二绑定消息标识的其它模块交换协议消息。

最好该模块具有用于处理所述协议消息的、针对每个所述实例的不同配置选项，并且其中每个所述绑定消息包括用于确定在所述相应模块实例的执行中实现哪些配置选项的标识符。

最好所述或每个模块在一个单独执行过程中被执行。最好每个执行过程是线程。

最好所述协议消息的交换是由来自模块执行的过程中的单独执行过程来进行。

最好所述消息被投送(post)到存储器的永久消息队列中，并且从该队列中取出。

最好该方法还包括：加载中间函数映射对象到存储器中，该对象在第一函数映射对象中包括对应于通用函数和一或多个特定于设备的函数的中间函数指针，以便在第一函数映射对象中把所述通用函数映射到一或多个中间函数指针，并且还映射到一或多个特定于设备的函数。

最好该协议是通信协议堆栈，并且最好是无线通信协议堆栈。

具体在另一方面，本发明提供了一种提供用于在处理设备中处理信号的动态可重构协议堆栈的方法，该处理设备具有处理器和存储器，该协议由多个协议层定义；该协议堆栈包括：若干软件模块，被载入到存储器中，每个模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在相应函数映射对象中包括对应于通用函数的通用函数指针；若干函数映射对象，被载入存储器中，所述对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到相应模块中的一或多个特定于设备的函数；基于所映射的特定于设备的函数执行所述模块，以便基于相应协议层处理所接收信号；该方法包括：每个模块接收包括另一所述模块的标识符的绑定消息，该接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

最好该方法还包括：加载升级软件模块到存储器中，该模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于通用函数的通用函数指针；加载函数映射对象到存储器中，该对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；基于所映射的特定于设备的函数执行模块，以便基于该协议层处理所接收信号；所述模块接收包括另一所述模块的标识符的绑定消息，所述接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

具体在另一方面，本发明提供一种基于协议处理信号的方法，该协议由多个协议层定义；该方法包括：基于对应于所述层之一的一组通用函数接收和处理所述信号；把通用函数映射到特定于设备的函数；执行所映射的特定于设备的函数以便基于所述协议层处理所接收信号。

最好该方法还包括：基于对应于其它所述层的一组通用函数接收和处理所述信号；把通用函数映射到特定于设备的函数；执行所映射的特定于设备的函数以便基于所述其它协议层处理所接收信号。

最好接收和处理被设置成使得通用函数的顺序对应于协议堆栈。

最好该方法还包括接收绑定消息以便确定处理所述信号所依据的通用函数的顺序。

最好基于每个层的通用函数的接收和处理通过执行软件模块来实现。

最好该方法还包括把通用函数映射到中间函数，接着映射该中间函数到所述特定于设备的函数。

在另一方面，本发明提供一种提供用于处理信号的通信协议的设备，该设备具有处理器和存储器，该协议由多个协议层定义；该设备包括：用于加载软件模块到存储器中的装置，该模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于通用函数的通用函数指针；用于加载函数映射对象到存储器中的装置，该对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；用于基于所映射的特定于设备的函数执行该模块以便基于所述协议层处理所接收信号的装置。

最好该模块被设置成与其它模块交换对应于信号的协议消息，所述其它模块被设置成基于对应于其它层的一组通用函数处理信号。

最好该设备还包括用于加载其它软件模块到存储器中的装置，所述其它模块在函数映射对象中包括对应于通用函数的通用函数指针；用于针对每个其它模块加载函数映射对象到存储器中的装置，该对象包括对应于通用函数的特定于设备的函数指针，以便把通用函数映射到一或多个特定于设备的函数；用于基于所映射的特定于设备的函数执行所述其它模块，以便基于所述协议层处理所接收信号的装置。

最好该设备还包括用于向所述或每个加载的软件模块发送包括另一所述模块的标识符的绑定消息的装置，第一模块被设置成与由所述绑定消息标识的其它模块交换协议消息。

最好该模块具有用于处理协议消息的不同配置选项。

最好该绑定消息包括用于确定在模块执行中实现哪个配置选项的标识符。

最好该协议消息，绑定消息和通用函数指针具有公共通用格式。

最好该设备还包括：用于加载第二软件模块到存储器中的装置，该第二模块被设置成基于对应于所述层中的第二层的一组通用函数接收和处理信号，该第二模块在第二函数映射对象中包括对应于通用函数的通用函数指针；用于加载第二函数映射对象到存储器中的装置，该对象包括对应于通用函数的第二特定于设备的函数指针，以便把该通用函数映射到一或多个第二特定于设备的函数；用于基于所映射的第二特定于设备的函数执行该第二模块，以便基于所述协议层处理所接收信号的装置；使得所述第一和第二模块在不同执行或特定于设备的环境中被执行。

最好该模块是语言无关的。

最好该设备还包括用于将基于对应于所述层的所述一组通用函数来处理信号的高级软件语言代码编译成所述语言无关软件模块的装置。

最好该设备还包括用于基于所述映射的特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供该模块的2个逻辑实例的装置。

最好该设备还包括：用于加载第二函数映射对象到存储器中的装置，该对象包括对应于通用函数的第二特定于设备的函数指针，以便把该通用函数映射到一或多个第二特定于设备的函数；以及除所述第一执行装置之外，用于基于所述映射的第二特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供所述模块的2个逻辑实例，使得该模块的2个实例基于不同函数映射对象被执行的装置。

最好所述2个执行过程在不同执行或特定于设备的环境中执行。

最好该设备还包括接收包括另一模块的标识符的第二绑定消息的所加载软件模块的第二实例，第一模块的第二实例被设置成与由第二绑定消息标识的其它模块交换协议消息。

最好该模块具有用于处理所述协议消息、针对每个所述实例的不同配置选项，并且其中每个所述绑定消息包括用于确定在所述相应模块实例的执行中实现哪个所述配置选项的标识符。

最好所述或每个模块在一个单独执行过程中被执行。最好每个执行装置包括线程。

最好该设备还包括：用于加载中间函数映射对象到存储器中的装置，该对象在第一函数映射对象中包括对应于通用函数和一或多个特定于设备的函数的中间函数指针，以便在第一函数映射对象中把所述通用函数映射到一或多个中间函数指针，并且还映射到一或多个特定于设备的函数。

最好该设备是通信终端，基站或网络设备；尤其是无线相关设备。

具体在另一方面，本发明提供一种用于提供在处理设备中处理信号的动态可重构协议堆栈的设备，该处理设备具有处理器和存储器，该协议由多个协议层定义；该设备包括：若干软件模块，被载入到存储器中，每个模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在相应函数映射对象中包括对应于通用函数的通用函数指针；若干函数映射对象，被载入存储器中，该对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到相应模块中的一或多个特定于设备的函数；用于基于所映射的特定于设备的函数执行该模块，以便基于所述相应协议层处理所接收信号的装置。

最好该设备还包括用于向每个模块发送包括另一所述模块的标识符的绑定消息的装置，所述接收模块被设置成与由所述相应绑定消息标识的其它模块交换协议消息。

最好该设备还包括：

用于加载升级软件模块到存储器中的装置，该模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于该通用函数的通用函数指针；用于加载函数映射对象到存储器中的装置，该对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；用于基于所映射的特定于设备的函数执行该模块，以便基于所述协议层处理所接收信号的装置；所述模块接收包括另一所述模块的标识符的绑定消息，所述接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

具体在另一方面，提供一种用于基于协议处理信号的设备，该协议由多个协议层定义；该设备包括：用于基于对应于所述层之一的一组通用函数接收和处理所述信号的装置；用于映射通用函数到特定于设备的函数的装置；用于执行所映射的特定于设备的函数，以便基于所述协议层处理所接收信号的装置。

最好该设备还被设置成基于对应于所述层的其它层的一组通用函数处理该信号；用于映射通用函数到特定于设备的函数的装置；用于执行所映射的特定于设备的函数，以便基于所述其它协议层处理所接收信号的装置。

最好接收和处理被设置成使得通用函数的顺序对应于协议堆栈。最好该设备还包括用于接收绑定消息以便确定处理所述信号所依据的通用函数的顺序的装置。

最好基于每个层的通用函数的接收和处理通过执行软件模块来实现。

最好该设备还包括用于把通用函数映射到中间函数，接着映射该中间函数到所述特定于设备的函数的装置。

还提供一种计算机或处理设备程序，用于控制处理设备以执行任意以上所定义的方法。还提供一种基于任意以上所定义的设备进行配置的可配置设备。还提供了一种携带处理器控制代码的承载介质，所述代码用于实现基于任意以上定义的方法或设备。

还提供了基于以上定义的软件模块，其适于执行或实现以上所定义的方法和设备。实现协议层和映射对象的模块可以可选地被实现为其它数据结构。

还提供可以实现为软件模块的配置管理器，并且该配置管理器被配置成发送绑定消息到实现协议堆栈的所述层的模块。配置管理器也可以被配置成加载该模块到工作存储器并且传递相应映射对象到加载的模块。

管理器也可以被配置成下载用于实现修改的协议堆栈的新的或替换模块，通过传递绑定消息到新的或替换模块，并且在适当的情况下传递到被替换的模块，重新配置该协议堆栈。

还提供编译器，用于编译高级程序代码为模块和/或映射对象，以及配置管理器。

还提供一种方法和设备，用于发送用于以上所定义的方法和设备的模块。还提供一种方法和设备，用于发送对应于用于以上所定义的方法和设备的模块的程序代码；并且可选地，用于编译该代码以产生相应模块。

具体在另一个方面，提供了一种灵活协议堆栈，包括若干协议软件层，每个层包括用于在运行时刻接收绑定消息以确定与哪个其它协议堆栈层交互，使得该堆栈在运行时刻动态可配置的装置。

最好该交互包括发送和/或接收来自其它所述层的协议消息。

最好该绑定消息包括与其它层相关、唯一标识协议消息被发送到的位置的标识符。

最好该绑定和协议消息具有公共通用格式。

最好每个层还包括通用函数和用于把该函数映射到对应于运行所述层的执行环境的特定于执行环境的函数的装置。

最好该装置包括在运行时刻接收绑定消息中的操作系统表。

最好该表具有从每个通用函数到相应特定于执行环境的函数的指针。

可选地，该表具有对应于每个通用函数的特定于执行环境的函数。

最好所述层的至少两个层在不同执行环境中运行，或用不同编程语言编写。

最好所述层的所述或每个执行环境被设置成为每个层分配标准操作系统，或定制执行线程或进程。

最好该绑定消息还包括所述层的配置信息。

最好所述层被实现为所述层的若干逻辑层实例之一。每个逻辑层实例在不同执行环境中可唯一标识，可配置以及可执行。

还提供了包括基于以上定义的一或多个协议堆栈的通信设备。

最好该协议堆栈提供一种无线通信链路或网络。

还提供了实现基于以上定义的协议堆栈的方法。

还提供了实现基于以上定义的协议堆栈的设备。

还提供了一种用于灵活协议堆栈的协议软件层，该协议堆栈包括若干协议软件层，该协议软件层包括用于在运行时刻接收绑定消息以确定与哪个其它协议软件层交互，使得该堆栈在运行时刻动态可配置的装置。

具体在另一方面，提供一种灵活协议堆栈，包括若干协议软件层，每个层包括通用函数和用于把所述函数映射到对应于将运行所述层的执行环境的特定于执行环境的函数的装置。

最好该映射装置包括用于在运行时刻接收包含操作系统函数映射的消息的装置。

最好该映射具有从每个通用函数到相应的特定于执行环境的函数的指针或其它引用装置。

最好该映射具有对应于每个通用函数的特定于执行环境的函数。

最好该映射具有从每个通用函数到相应虚拟操作系统映射的指针或其它引用形式，其中虚拟操作系统映射允许特定于执行环境的函数被调用。

可选地，该映射具有对应于每个所述通用函数的虚拟操作系统函数，每个虚拟操作系统函数对应于特定于执行环境的函数。

最好所述堆栈还包括用于在运行时刻接收绑定消息以确定与哪个其它协议软件层交互，使得所述堆栈在运行时刻动态可配置的装置。

最好该交互包括发送和/或接收来自其它所述层的协议消息。

最好该绑定消息包括与所述其它层相关、指示协议消息被发送到的位置的标识符。

最好该绑定和协议消息具有公共通用格式。

最好所述层的至少两个层在不同执行环境中运行和/或用不同编程语言编写。

最好所述层的所述或每个执行环境被设置成为每个层分配标准操作系统，或定制执行线程或进程。

最好该绑定消息还包括所述层的配置信息。

最好所述层被实现为所述层的若干逻辑层实例之一。每个逻辑层实例在不同执行环境中被可唯一标识，可配置以及可执行。

最好相同层的不同层实例能够在不同执行环境被运行。

最好相同层的不同层实例能够被不同地配置。

还提供了包括基于以上定义的一或多个协议堆栈的通信设备。

最好该协议堆栈提供一种无线通信链路或网络。

还提供了实现基于以上定义的协议堆栈的方法。

还提供了实现基于以上定义的协议堆栈的设备。

还提供一种用于灵活协议堆栈的协议软件层，该灵活协议堆栈包括若干协议软件层，该协议软件层包括通用函数和用于把所述函数映射到对应于运行所述层的执行环境的特定于执行环境的函数的装置。

具体在另一方面，还提供一种用于基于动态可配置协议堆栈处理信号的设备；该设备包括：若干处理装置，用于基于所述协议堆栈的层处理对应于该信号的分组；第一处理装置，被设置成传递基于堆栈的所述第一协议层处理的分组到用于基于堆栈的另一协议层进行处理的另一处理装置；该第一处理装置具有用于动态改变分组所传递到的其它处理装置，使得该第一处理装置在改变期间继续处理分组的装置。

最好所述处理装置是在由处理器和存储器装置提供的执行环境中执行的软件代码模块。

最好用于动态改变的装置包括用于接收包括对应于传递分组到达的其它模块的标识符的绑定消息，该标识符由所述第一模块用以传送基于堆栈的所述第一协议层处理的分组到其它模块，以基于堆栈的另一协议层进行处理。

具体在另一方面，还提供用于基于动态可配置协议堆栈处理信号的设备；该设备包括：处理器和存储器装置，用于执行若干协议层软件模块，每个所述软件模块被设置成用以基于协议堆栈的协议层处理对应于所述信号的分组；为处理器和存储器装置配置的执行环境软件模块，该模块适于执行一或多个协议模块；第一模块被设置成在运行时刻接收映射标识符，用于把所述协议模块中的指令映射到执行环境模块中的相应指令，以便使用处理器和存储器装置运行该协议模块。

具体在另一方面，提供了一种用于提供在处理设备中提供处理信号的动态可重构通信协议的方法，该处理设备具有存储器，该协议由多个协议层定义；该方法包括：加载软件模块到存储器中，该模块被设置成基于对应于所述层之一的一组函数接收和处理所述信号，该模块接收对应于存储器中的另一软件模块的目的模块标识符，该另一软件模块被设置成基于对应于所述层中另一层的另一组函数接收和处理所处理的信号；该第一模块被设置成发送所处理的信号到对应于该标识符的其它模块；执行该第一模块，使得所接收的信号被该模块处理，并且被发送到对应于所述目的模块标识符的其它模块。

这允许协议堆栈在运行时刻动态可重构，而不需要中间层。

具体在另一方面，提供一种灵活协议堆栈，包括若干协议软件层，每个层包括通用函数和用于把所述函数映射到对应于将运行所述层的执行环境的特定于执行环境的函数的装置。

具体在另一方面，提供了一种用于在处理设备中提供用于处理信号的通信协议的方法，该处理设备具有存储器，该协议由多个协议层定义；该方法包括：加载软件模块到存储器中，该模块被设置成基于对应于层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于通用函数的通用函数指针；加载函数映射对象到存储器中，该对象包括对应于通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；执行该模块以便基于该协议层处理所接收信号。

信号格式可以使用可扩展模板定义来定义，并且也使用通用函数来产生信号及访问其数据单元。用于产生和访问信号数据单元的通用函数的行为可以由在运行时刻提供的模板确定。因而允许数据存储机构和格式针对特定执行环境而优化，但不用使用知道其特定细节的信号数据的软件模块。

这允许实现协议堆栈的所述层的模块是平台和/或语言无关的。

通常而言，在另一方面，本发明提供一种具有若干协议层的协议堆栈，该堆栈被设置成使得存在与每个LLI相关的一个主操作系统执行线程。

换句话说，当该(所处理)分组从一个LLI传递到另一LLI时，它只是通过通常被称为线程消息传递的方法从一个线程传送到另一个。这使得易于动态升级或替换在协议堆栈中的一个层，而不影响协议堆栈内的其它LLI。LLI之间传递的消息可以使用永久存储器存储机构来排队，以允许不丢失分组地实时动态重新配置。

具体在一个方面，提供一种用于处理信号的协议堆栈，该堆栈包括若干协议软件层，用单独进程(例如线程)执行每个层，并且每个层被设置成通过与所述进程无关的消息来传递部分处理的信号到另一层。

通过提供多个执行环境进程以执行一个层，可以提供每个层的多个逻辑层实例(LLI)，每个LLI能够或具有不同配置选项，并且可选地，在不同执行环境中执行。

最好每个层还包括通用函数和用于把该函数映射到对应于将运行所述层的执行环境的特定于执行环境的函数的装置。

最好该装置包括在运行时刻接收绑定消息中的操作系统表。

最好该表具有从每个通用函数到相应特定于执行环境的函数的指针。

最好该表具有对应于每个通用函数的特定于执行环境的函数。

最好所述层的至少两个层在不同执行环境中运行或用不同编程语言编写。

最好所述层的所述或每个执行环境被设置成为每个层分配标准操作系统，或定制执行线程或进程。

每个所述层被实现为所述层的若干逻辑层实例之一。每个逻辑层实例在不同执行环境中可唯一标识，可配置以及可执行。

最好所述堆栈还包括用于在运行时刻接收绑定消息以确定与哪个其它协议软件层交互，使得所述堆栈在运行时刻动态可配置的装置。

最好该交互包括发送和/或接收来自其它所述层的协议消息。

最好该绑定消息包括与所述其它层相关的、指示协议消息被发送到的位置的标识符。

最好该绑定和协议消息具有公共通用格式。

最好该绑定消息还包括所述层的配置信息。

具体在另一方面，提供了一种用于在处理设备中提供用于处理信号的通信协议的方法，该处理设备具有存储器，该协议由多个协议层定义，其中每个协议层对应于该存储器中的软件模块；该方法包括：针对每个所述层，加载被设置成基于对应于所述层的一组函数接收和处理所述信号的软件模块，并且发送所述处理的信号到另一模块；将每个所述模块作为独立进程(例如线程)来执行，从而所述处理信号独立于所述进程地被发送到所述其它模块。

这允许不同模块在不同执行环境更加容易地操作，并且提供通过所述模块的更好分组流。

通常而言，在另一方面，本发明提供具有若干协议层的一或多个协议堆栈，所述层可以被多次实例化为单独逻辑实例，例如使用不同线程。

所述多个LLI可以用不同选项配置，例如无论加密是否被允许。所述相同层的多个实例也可以被配置成在不同执行环境执行，诸如在不同操作系统进程内，或甚至在不同操作系统中。通过允许不同层实例在具有不同安全性和性能配置的不同执行环境中运行，这提供了额外的安全性或性能。

因而2个协议堆栈实例可以包括相同软件协议层的不同LLI，其中每个LLI直接与其相应堆栈内上面和/或下面的LLI交互。

LLI之间的交互包含使用在支持相应LLI的所述执行环境内容易得到支持的方法传递或传送协议消息，以及也具有合适的性能特性。所使用的机构可以针对不同LLI而不同。因此，公共命名约定和通用可扩展消息数据格式对于所述协议和控制消息是需要的，以保证互操作性。

具体在一个方面，提供一组2个协议堆栈，每个协议堆栈包括若干协议层，其包含具有配置选项的公共层，所述公共层被实例化为每个所述堆栈的逻辑层实例；其中每个实例具有不同配置。

最好每个层还包括通用函数和用于把该函数映射到对应于将运行所述层的执行环境的特定于执行环境的函数的装置。

最好该装置包括在运行时刻接收绑定消息中的操作系统表。

最好该表具有从每个通用函数到相应特定于执行环境的函数的指针。

最好该表具有对应于每个通用函数的特定于执行环境的函数。

最好所述层的至少两个层在不同执行环境中运行或用不同编程语言编写。

最好所述层的所述或每个执行环境被设置成为每个层分配标准操作系统，或定制执行线程或进程。

每个所述层被实现为所述层的若干逻辑层实例之一。每个逻辑层实例在不同执行环境中可唯一标识，可配置以及可执行。

最好所述堆栈还包括用于在运行时刻接收绑定消息以确定与哪个其它协议软件层交互，使得所述堆栈在运行时刻动态可配置的装置。

最好该交互包括发送和/或接收来自其它所述层的协议消息。

最好该绑定消息包括与其它层相关、指示协议消息被发送到的位置的标识符。

最好该绑定和协议消息具有公共通用格式。

最好该绑定消息还包括所述层的配置信息。

具体在另一方面，提供了一种用于在处理设备中提供用于处理信号的通信协议的方法，该处理设备具有存储器，该协议由多个协议层定义，其中每个协议层对应于该存储器中的软件模块；该方法包括：针对每个层，加载被设置成基于所述层接收和处理所述信号的软件模块，至少一个所述模块具有配置选项；通过提供2个独立执行进程以执行模块，提供具有配置选项的所述模块的2个逻辑实例；针对所述模块提供对应于不同配置选项的2个配置对象；使用所述2个独立执行进程执行所述模块，每个进程使用不同配置对象，使得所述模块的每个逻辑实例所接收的信号被不同地处理。

这避免了不得不进行的所述代码模块的两次拷贝，基于所述不同选项略微修改每个拷贝。也允许在不同执行环境中执行所述堆栈的所述不同实例，以允许使用不同性能和安全性措施。

通常而言，在另一方面，本发明提供一种用于包括实现为模块的若干协议层的动态可重构协议堆栈的配置管理器，所述管理器被设置成发送绑定消息到所述模块，以向该模块指示与哪个其它模块进行交互。

通常而言，在另一方面，本发明提供一种用于包括实现为模块的若干协议层的动态可重构协议堆栈的配置管理器，其中模块包括通用函数指针，所述管理器被设置成在执行环境中加载所述模块并且把一组执行环境函数与每个所述模块相关联，以便所述通用函数指针对应于所述相关的执行环境函数。

上面提供的本发明的各方面可以被实现为方法或设备。本发明还提供程序代码或软件对象，诸如当在适当平台(硬件，包含处理器和存储器，以及操作系统或平台内核，及可选的虚拟机环境)上实现时提供这些方法和设备的所述功能的模块。这个代码可以是对象，字节代码或可执行代码块或模块的形式，或某些其它数据结构的形式。所述代码也可以是用诸如C或Java的高级语言编写的源代码的形式。

本发明还提供一种能够把所述高级程序代码转换成适于实现本发明各方面的对象代码模块或数据结构的编译器。所述编译器可以直接编译高级代码成适用于本发明的实施例的对象代码，或可以编译所述高级代码成中间形式。在这种情况下，提供另一编译器以转换所述中间形式代码成适用于本发明的实施例的对象代码模块。

附图说明

现在参照下列附图描述实施例，其仅作为例子并且不旨在限制本发明，其中：

图1示出通信协议堆栈；

图2示出图1的通信堆栈的抽象层；

图3示出实现动态重新可配置通信协议堆栈的已知结构；

图4示出基于实施例的动态可重构协议堆栈的结构；

图5图解了绑定消息；

图6图解了函数指针表；

图7图解了协议消息；

图8，9，10和11图解了层软件以及特定于操作系统的映射对象的多个实施例；

图12图解了基于实施例的层的多个实例化；

图13图解了基于所述实施例的协议堆栈中的软件层的实例化和绑定；

图14图解了实施例的块代码说明；

图15图解了基于实施例的虚拟操作系统；

图16和17分别针对C代码示出已知动态链接方法和操作系统函数表传递方法；

图18和19分别针对Java代码示出已知动态链接方法和操作系统函数表传递方法；

图20示出每个消息协议堆栈结构的已知线程；

图21示出示意性存储器结构，用于图16和17的所述实施例；

图22图解基于实施例的每层结构的线程；

图23示出示意性存储器结构，用于图20的所述实施例；

图24和25示出编译高级源代码成实施例中使用的模块的两种方法；

图26图解了基于实施例的Bluetooth^TM复杂协议堆栈的例子实现；以及

图27图解了升级Bluetooth^TM协议堆栈。

具体实施方式

图1图解了本领域的技术人员熟悉的通信协议堆栈。所述协议堆栈包括若干软件或协议层L1-L7，其中通过这些层处理信号或协议消息。例如，应用程序(L7)可以是Web浏览器或用于GSM语音呼叫的控制器，应用程序(L7)产生的信号和消息向下通过低层L1-L6处理，以便通过诸如无线电波，铜线或光缆的一些物理链路与传送到另一个应用程序。

图2示出通信堆栈层之一的简化的例子。每个层怎样工作的实际细节将取决于所使用的特定协议。层接收诸如部分语音呼叫或Web页的分组。层是对所接收的分组执行一系列预定步骤(协议)的软件进程。第一步骤执行校验和计算并且在必要时拒绝分组，然后消除分组头，并且另一个步骤解密其数据有效负载。在其它步骤中，在向外传递修改的并且更大的分组到更高层之前，层可以接着累积若干所接收的分组的数据内容。这个累积可以(并且通常)在共享的缓冲区(或队列)中执行，以避免不必要的存储器拷贝。通常，通信层还将在从层的较高到较低级的相反方向处理分组。在原理上，两个相邻层不需要“了解”其它层在做什么或怎样做；但实际上，层之间的接口需要根据所传递的数据(分组)内容的准确格式和缓冲区存储结构，以及其怎样实现来进行定义，例如了解传递这个数据到哪个层，和怎样启动这个处理所传递数据的层。这限制了前面针对已知方案描述的堆栈的灵活性。

通常，在移动电话等等中的常规不可重构通信协议堆栈在制造时被设置，在工作存储器中实例化各种软件层所需的软件代码在电话内是固定的，并且被存储为例如固件。这意味着如果层之一需要升级，则协议堆栈需要停机，并且全部代码，或至少升级层代码被改写到通信设备中，并且接着终端重新启动，并且所升级的协议堆栈重新实例化。这需要终止通信设备上的任何活动呼叫，并且使设备将呼叫断开。这个方法的另一个问题是不同的层通常用非常特定的方式互相接口，以使协议堆栈的工作象一些上面的参照文献中一样。这意味着新或升级的软件的提供商需要事先确切知道对于特定实现和平台，怎样与上层和下层交互。这再次限制了堆栈的灵活性。

在运行时刻支持协议堆栈的重新配置的其它所提出的方法允许下载协议软件，并且使用特定于执行环境和编程语言的机构，通过暂时挂起堆栈执行并链接新软件到现有堆栈，从而动态插入协议软件到现有协议堆栈中。这再次需要活跃通信会话的临时挂起，以及需要新软件的提供商在提供特定于语言和操作系统的命令及数据格式方面，知道与哪个其它堆栈软件进行接口，特定于有关层的共享分组缓冲区结构，以及怎样去做。这些方法还具有风险，即如果软件运转不良，则它能够破坏许多活跃通信会话，直到问题被检测以及欺骗软件被消除。并且，允许新模块的插入的层间接口不能容易地升级或单独配置，以约束协议软件的不同逻辑实例之间的交互，因为逻辑实例对通用接口层是不可见的。

另外，可能需要这样的特性，使得各层以不同于其它层的软件语言来编写。例如靠近物理层的层需要快速处理，因此可以预编译成高度优化的特定于硬件的机器语言以便快速执行，而堆栈中较高的层可以是平台无关的，因此在虚拟机环境或解释器上运转，因此更慢但更有灵活性，以便允许平台无关，因此鼓励第三方开发新应用程序。然而，使用不同语言的两个层在特定于语言的数据结构，命名约定(名称解析约定(name mangling convention))以及函数调用(参数传递)约定方面不能使用已知公共语言。

当前方法的另一个问题是，当每个层被接口定义(包含共享缓冲区结构)紧密限制时，它们限制了升级堆栈的能力，其中所述接口定义支持其上面和下面的层之间的交互，此交互通常是特定于语言和操作系统(执行环境)的。这种情况在可能出现的情况下被恶化，即在将来协议堆栈的不同层将由不同厂商提供，这些厂商将不得不针对其需要与之接口的层，提供使用相同语言(和甚至在某些情况下，相同的编译器)和接口函数以及共享缓冲区格式的接口。

在图3图解了提供动态灵活Java协议堆栈的一个已知方法，其利用每个协议堆栈层(L1-L4)之间的接口层。这对应于在WO 01/88707中的公开内容。两个协议堆栈层之间实例化其接口格式被其上层和下层“已知”的接口或中间层。接口层查找一个表以确定它应当与哪个更高协议层接口，并且接着使用已知(Java)接口。因而在所示出的例子中，升级的协议层L2′被实例化，并且接口层I1根据查找表确定它现在应当把来自层L1的分组传送到层L2′而不是层L2。层L2′接着传送分组到接口层I2，接口层I2重定向这些分组到协议堆栈层L3。因而通过使用每个协议堆栈层(L1-L4)之间的这些接口层(I1-I3)和查找表，协议堆栈能够被动态重新配置。然而仍然需要明确定义接口和协议层之间的链接(各层都在JVM中，或并且使用诸如类加载，继承，类创建和销毁的Java语言特性，以及方法标识和调用约定)，以及在必要时被执行以提供正确接口的转换(封装函数)。并且，当接口层同步支持相邻层之间的交互时，它不支持用于存储分组的共享的缓冲区结构，当在不同层之间传递消息时，这能够导致过多分组数据拷贝和存储器需求。另外，虽然这个方法足够用于单语言协议堆栈，然而在不同语言的层被用作各种函数调用，并且格式化数据必须在特定于语言的格式和命名约定之间进行转换的情况下，它将变得麻烦，所述转换极其消耗处理器和存储器。

图4图解了基于实施例的协议堆栈。堆栈包括若干协议层(L1-L4)，在它们之间传递诸如信号分组的协议消息(图7)。虽然这些层从低到高层进行示出，然而会理解，相同原理同样适用于向下通过堆栈的信号进程。每个层接收绑定消息(图5)并且包括从绑定消息确定向哪个其它层传送输出的绑定处理程序。

输出被传送到的下一层由唯一标识符(绑定引用(bind ref.))指示。在层之间传递消息的优选方法使用永久消息队列，但其被执行以及怎样把执行从一个层传递到另一个层的方式的具体细节是从下面更详细描述的协议层软件抽象出的。

参考图5，绑定消息包含例如L2的唯一LLI名或标识符(instance.ref)。在相同层的多个逻辑层实例(LLI)被并行使用(例如在处理不同调用的另一个堆栈实例中)的情况下，该LLI名唯一标识与相同层的其它实例相比的该层实例；例如L2₁以及L2₂。在下面更详细描述层的多实例化。

该绑定消息也可以包括特定于语言的函数表，该表表示操作系统应用程序员接口(API)，该接口能够被动态封装成Java或C++“协议堆栈操作系统”类，或包含在C结构中，以及用于在层软件内访问它们的一组封装函数(wrapper function)。该函数表包括预定组的基本操作系统函数，诸如新LLI实例创建(create_new_LLI)和LLI消息传送(send_message.receive_message)。所提供的表将取决于将运行该层(或甚至该层的多个LLI之一)的执行环境。换句话说，函数自身是特定于操作系统或虚拟机(例如JVM)环境的，然而，因为在绑定时间它们被传递到该层(实例)，这意味该层(实例)自身是操作系统和执行环境无关的，并且使用该函数表以适当方式与其堆栈中的其它层交互。

在候选方案中，该绑定消息包含指针(function.pointer)，其指向例如被存储在共享存储器的表中的所需的特定于操作系统的函数。

在图6的图解中，由各层使用的预定通用函数(Func#1-Func#n)被映射到特定于操作系统的函数(op.sys.func1.-op.sys.funcn)。示出一些典型的示例性函数，例如create_new_LLI，操作系统代表该层执行这些函数。

因而，每个层将包括通用函数调用(Func#1-Func#n)，这些调用允许该层与其它层互操作，但是当特定于操作系统的函数在绑定时间被传递到该层时，不知道它将在哪个操作系统环境中执行。这也可以从实现为代码模块的软件层抽象出用于支持LLI之间交互的特定类型的进程间通信(消息传送)以及安全机制。唯一的要求是层的厂商必须使用适当的预定通用函数调用-例如使用Func#1以启动新LLI，使用Func#2以发送消息到另一个LLI，使用Func#3以接收来自另一个LLI的消息，等等。类似地，当两个LLI将被传送相同特定操作系统函数时，它们将能够通过使用相同消息传递函数来相互接口。

进一步地，两个LLI能够被传递不同的特定于操作系统的函数，并且从而使用如下更详细描述的虚拟操作系统函数表在不同执行环境中操作。通过这种方式，各层是操作系统及语言无关的。与堆栈的其余部分互操作所需的特定于操作系统的函数在绑定/重绑定时传递给它们。

相同层的不同实例通过用其绑定消息被传递具有不同的特定于操作系统的函数的不同函数表，能够在不同环境中执行。因而，仅仅通过使不同类型的特定于操作系统的函数映射到每个LLI中的通用send_message和receive_message函数，单段代码(模块)能够与代码(模块)的其它位不同地交互(例如在一个中进行函数调用而在其它中进行异步消息传递)。这是由于用于映射通用send_message函数到相应特定于操作系统的函数的表是逐个LLI地执行的。然而，如果你希望LLI与另一个LLI成功通信，则需要使用从通用send_message和receive_message函数到操作系统函数的相同映射，否则接收LLI在LLI执行send_message时将不再接收任何内容。

绑定消息也可以包含层实例配置信息(config_1到config_n)，以向层的该逻辑实例适当配置层的实例。例如允许或禁止不同可选协议特性。

通过使用这个通用和非特定于层的绑定机构，每个逻辑层实例通过发送另一个绑定消息到与之交互的新逻辑层实例，能够动态(在运行时刻)地被导向该实例。可以发现，这可以包含新层的动态插入，并且还允许层之间的语言无关的交互。

参考图7，协议消息在层之间传递，以在协议堆栈上下传送信号或分组信息。基于与发送层相关并且通过其绑定消息提供给发送层(参见图5)的bind.ref标识符，每个协议消息将被从该发送层(例如层1)传送到目的层(例如层2)。协议消息也会包括信号数据或指向共享存储器中的信号数据的信号指针。再次地，信号数据(或指针)和标识符(send.inst.ref和dest.inst.ref)具有公共通用共享数据格式。

协议和绑定消息是在协议堆栈实体(各种LLI)之间传递的信号，并且这个信号传递可以使用诸如函数调用或线程消息传送机构的不同机构来执行。通常，线程消息传送在不同操作系统线程之间进行，并且消息被放在队列中，并且接着操作系统唤醒(调度)接收线程从队列读取消息。

通用函数(诸如send_message和receive_message)被用于允许以任何适合于用于该特定交互的目标平台的方法进行消息传递。代码自身不需要了解使用什么方法。然而，调用send_message函数需要被发送的消息具有通用格式并且以预定的方式传递到send_message函数。消息可以通过使用create_message函数(也在特定于操作系统的函数的表内提供)被动态产生和识别，其中通用create_message函数产生可以在send_message函数内使用的消息的句柄(或引用)。传递消息到send_message函数的优选方法是通过引用传递消息(指向消息的指针在函数调用中被传递)。这最小化必须进行的数据拷贝的量，因为否则消息数据将被从堆(或共享)存储器复制到栈存储器，并且接着返回到堆或共享存储器。优选方法是高效的，并且不涉及消息数据的过多拷贝。事实上，如果消息数据总是保持在堆或共享存储器中，则根本不需要拷贝。

因而层软件(模块)不需要任何有关其正发送消息到的软件层(模块)内使用什么语言或甚至什么调用约定的知识，因为它只需要知道对它可用的send_message和create_message函数的调用约定。并且同样地，接收软件层(模块)仅需要知道有关receive_message函数的情况。接着必须访问实际消息内容，并且公共通用共享数据存储方法和特定于语言的访问函数一起被用以访问这个数据。通过相同方式，绑定消息或协议消息(分组)可以被每个层以通用方式访问，而不考虑编程语言和执行环境。

用于访问数据的函数可以作为绑定消息内特定于操作系统的函数的一部分被传递到软件层(代码模块)。为允许通过不同编程语言高效访问的消息(或信号)，配置和共享数据，并且也为了允许升级，格式必须是可扩展的。例如，通过使用唯一标识符标识数据单元及其相应数据类型，可扩展标记语言(XML)或其它(诸如抽象语法表示ASN.1)模板定义可以被用于定义数据格式，以及在运行时刻访问共享数据存储结构。特定于语言的数据访问函数可以高效获得所需单元。这允许协议软件的不同版本使用相同数据。旧版本会不需要访问新数据成员，并且不会尝试访问它们。也可以在新软件版本中消除有关过时数据成员的知识，但数据模板定义会仍然具有过时数据成员的位置标志符(placeholder)，以支持旧软件模块版本。唯一标识数据成员(包括所有过时数据成员)的标识符在软件模块内使用，以访问这些数据成员。然而，由于特定于语言的数据访问函数提供的间接寻址(indirection)，实际数据可以被全部存储在公共共享存储器区域中，并且采取适当安全措施(诸如使用读、写锁定机构的数据类型或单元级授权)以阻止个别LLI未经授权地访问数据。

这些函数可以被封装在更加复杂的接口定义语言(IDL)模式内，以允许发掘现有或新部件技术的特性。特定于语言的IDL定义也可以允许发掘复杂数据类型的能力，其中复杂数据类型不能方便地在不同语言之间进行映射(例如一组Java类和Java层的部件接口，以及C++层的一组C++接口类，等等)。针对XML或ASN.1模板的特定IDL的映射将需要由这个附加部件接口软件来处理。为改进使用公共存储器结构对大量共享数据的访问速度，标识符可以按层次结构被排列在链表中，或顺序排列在数组内，以最小化定位期望单元所需的查找时间。

编程语言无关的数据模板定义的例子分别是可扩展标记语言(XML)模式或抽象语法表示(ASN)标记或数据序列定义。数据单元(或属性)访问函数可以利用间接寻址(存储器指针)访问数据单元序列内的实际项，以改进访问性能，如下表中所示。通过这种方式，数据单元的解析变成查找操作，以及模板中定义的结果到所需数据格式的投射casting或转换结果为强制类型转换(casting)或转换。

标识符	类型	存储器指针
			1	整型	XXXXXXXX
2	串	YYYYYYYY
			.		.

其中例子ASN-1定义为：

Message∷＝SEQUENCE{

Message_Number INTEGER OPTIONAL，

Message_Name STRING

}

用于访问消息数据的通用函数也可以包含在与绑定消息一起传递的函数的通用操作系统表内，以允许针对平台优化数据访问函数的实际实现。例如对于具有唯一标识符“1243”的数据单元，软件层调用通用层函数get_attribute(“1243”)。层软件需要知道在XML或ASN.1模板格式中定义的单元的数据类型。对应于层软件使用的配置数据和消息的模板需要被通用get_attribute和set_attribute函数知道，以便允许所需的类型转换。因此，get_attribute和set_attribute函数以针对模板定义的句柄(引用)作为参数。句柄(或引用)由通用load_template函数产生。通用函数get_attribute和set_attribute也将得到配置数据或消息句柄(或引用)并且保存查找表，以便能够存储特定数据单元的存储器指针引用并且记录其唯一标识符引用。

另一个选项是使两个属性标识符指向相同实际数据单元。当不同标识符实际上对应于相同数据单元但具有不同转换类型时，这对避免数据复制有吸引力。例如，如果数据单元标识符″1243″对应于在模板内指定作为“消息名”并且是null结束的Unicode串的数据单元。属性标识符″1244″也可以对应于相同“消息名”但具有不同格式，例如255字节ASCII字符串。类型转换可以通过get_attribute函数对软件层。因此，如果Java软件模块调用get_attribute，则它将使用标识符″1243″并且得到Unicode串，并且如果C++模块希望访问数据单元，则它可以对“1244”单元调用get_attribute并且得到255字节ASCII字符串。

在优选实施例中，相同模板被用于全部消息数据，而不考虑正发送和接收消息的LLI。这提供了所谓的通用服务接入点(GSAP)给LLI，该LLI独立于LLI内的协议功能。GSAP的可能例子通用模板定义在下面示出。

--枚举和类型定义

GPI_PRIMITIVETYPE∷＝ENUMERATED{GPI_BIND(1)，

GPI_REBIND(2)，GPI_SUSPEND(3)，GPI_RESUME(4)，

GPI_UNBIND(5)，GPI_TERMINATE(6)，GPI_UPGRADE(7)，

GPI_OPTIMISE(8)，GPI_OK(9)，GPI_ERR(10)}；

--针对通用MAC层

GPI_MACTYPE∷＝ENUMERATED{GPI_CSMACA(0)，

GPI_CSMACD(1)，GPI_TPB(2)，GPI_TPR(3)，GPI_TDMA(4)}；

GPI_CRCTYPE∷＝ENUMERATED{GPI_CRC32(0)，

GPI_CRC16(1)，GPI_CRC24(2)}；

GPI_ARQTYPE∷＝ENUMERATED{GPI_SAW(0)，

GPI_GBN(1)，GPI_SEL(2)，GPI_NONE(3)}；

GPI_HARQTYPE∷＝ENUMERATED{GPI_TYPEI(0)，

GPI_TYPE2(1)，GPI_NONE(2)}；

GPI_HARQCODETYPE∷＝ENUMERATED{GPI_GOLAY(0)，

GPI_RS(1)，GPI_NONE(2)}；

GPI_CRYPTOTYPE∷＝ENUMERATED{GPI_RSA(0)，GPI_DES(1)，GPI_3DES(2)，GPI_GEA3(3)，GPI_NONE(4)}；

--针对绑定原语

GPI_QOSTYPE∷＝ENUMERATED{GPI_CO(0)，GPI_CL(1)}；

--面向连接和无连接

GPI_SECURITYLEVEL∷＝ENUMERATED{GPI_HIGH(0)，

GPI_MEDIUM(1)，GPI_LOW(2)}；

--针对通用数据分组原语

GPI_PACKETTYPE∷＝ENUMERATED{GPI_IP(0)，

GPI_ETHER(1)，GPI_PPP(2)}；

GPI_DIRECTION∷＝ENUMERATED{GPI_UP(0)，GPI_DOWN(1)}；

GPI_TFTYPE∷＝SEQUENCE{

--通用传送格式类型定义

GPI_MOD GPI_MODTYPE[调制类型]，

GPI_CODING GPI_CODINGTYPE[信道编码类型]，

GPI_BLOCKSIZE INTEGER[传送分组字节长度]，

GPI_ANTENNA INTEGER OPTIONAL[关于使用何天线的指示]

}

--原语定义

GPI_MANPRIMITIVE∷＝SEQUENCE{

--通用GPI管理原语

GPI_PRIMITIVE GPI_PRIMITIVETYPE[这是特定协议消息原语类型]，

--协议模块无关部分

GPI_REQUESTOR GPI_LL_IDENT[这是请求方LLI]，

--取决于原语类型的可选部分-绑定包含附加信息

GPI_BIND GPI_BINDPRIMITIVE OPTIONAL[用于绑定，再绑定，优化]

}

GPI_BINDPRIMITIVE∷＝SEQUENCE{

GPI_UPPER_SAP STRING[这是LLI之上的服务接入点名]，

GPI_UPPER_USER_GPI_LL_IDENT[这是使用SAP并且分组被接收和发送到的LLI的唯一标识符]，

GPI_LOWER_SAP_STRING[这是LLI之下的服务接入点名]，

GPI_LOWER_USER_GPI_LL_IDENT[这是使用SAP并且分组被接收和发送到的LLI的唯一标识符]，

GPI_GSAP_GPI_GSAP_TABLE[这是(虚拟)操作系统表，其设置LLI的环境以允许以安全方式在GSAP边界上进行语言无关的性能优化和交互]，

--QoS属性，以用通用方式配置LLI

GPI_QOS GPI_QOSTYPE[与LLI相关的QoS]，

GPI_RCV_THROUGH_TARGET INTEGER[以k位每秒为单位的目标接收吞吐率]，

GPI_RCV_THROUGH_ACCEPT INTEGER[以k位每秒为单位的可接受接收吞吐率]，

GPI_RCV_TRANSDELAY_TARGET INTEGER[以毫秒为单位的目标接收时延]，

GPI_RCV TRANSDELAY ACCEPT INTEGER[以毫秒为单位的可接受接收时延]，

GPI_XMT_THROUGH_TARGET INTEGER[以k位每秒为单位的目标发送吞吐率]，

GPI_XMT_THROUGH_ACCEPT INTEGER[以k位每秒为单位的可接受发送吞吐率]，

GPI_XMT_TRANSDELAY_TARGET INTEGER[以毫秒为单位的目标发送时延]，

GPI_XMT_TRANSDELAY_ACCEPT INTEGER[以毫秒为单位的可接受发送时延]，

GPI_PRIORITY_MIN INTEGER(0..100)[传输类/连接的最小优先级]，

GPI_PROTECTION_MIN INTEGER[GPI_NONE，GPI_MONITOR，GPI_MAXIMUM]，

GPI_PRIORITY_MAX INTEGER(0..100)[传输类/连接的最大优先级]，

GPI_PROTECTION_MAX INTEGER[GPI_NONE，GPI_MONITOR，GPI_MAXIMUM]，

GPI_RESILIENCE_DISC_PROB INTEGER(0..10000)[对断开的恢复能力]，

GPI_RESILIENCE_RESET_PROB INTEGER(0..10000)[对连接复位的恢复能力]，

GPI_RESIDUAL_SUCCESS INTEGER(0..10000000)[差错率的残留成功率倒数]，

--可选成本及功耗，资源利用及安全性要求

GPI_RCV_COST_TARGET INTEGER OPTIONAL[以货币为单位在目标吞吐率下每分钟的目标接收成本]，

GPI_RCV_COST_ACCEPT INTEGER OPTIONAL[每分钟的可接受接收成本]，

GPI_XMT_COST_TARGET INTEGER OPTIONAL[以货币为单位在目标吞吐率下每分钟的目标发送成本]，

GPI_XMT_COST_ACCEPT INTEGER OPTIONAL[每分钟的可接受发送成本]，

GPI_POWER_CONSUMPTION_TARGET INTEGEROPTIONAL(0..100)[作为允许实现可接受电池寿命的最大功耗的百分比的目标最大功耗]，

GPI_SECURITY GPI_SECURITYLEVEL OPTIONAL[所需安全等级]，

GPI_MEMORY_TARGET INTEGER(0..100)OPTIONAL[总使用的目标最大存储器使用百分比]，

GPI_PROCESSOR_TARGET INTEGER(0..100)OPTIONAL[总使用的目标最大处理器使用百分比]，

--LLI特定部分-这里使用的属性主要依赖于LLI的类型

GPI_MAC_GPI_MACTYPE OPTIONAL[这指示MAC的类型]，

GPI_MAC_AIFS INTEGER OPTIONAL[以时隙为单位的仲裁帧间间隔]，

GPI_MAC_SLOTTIME INTEGER OPTIONAL[以微秒为单位的基于CSMA和TDMA的MAC的时隙时间]，

GPI_MAC_FRAMESIZE INTEGER OPTIONAL[以时隙为单位的帧长度]，

GPI_MAC_BACKOFFWINDOW INTEGER OPTIONAL[以时隙为单位的初始补偿窗口尺寸]，

GPI_HEADER_CRC GPI_CRCTYPE OPTIONAL[通用组头CRC的设置]，

GPI_PAYLOAD_CRC GPI_CRCTYPE OPTIONAL[通用有效负载CRC的设置]，

GPI_HEADER_CRC_GEN INTEGER OPTIONAL[组头CRC的生成多项式]，

GPI_PAYLOAD_CRC_GEN INTEGER OPTIONAL[有效负载CRC的生成多项式]，

GPI_ARQ GPI_ARQ_TYPE OPTIONAL[ARQ的设置]，

GPI_ARQ_BLOCKSIZE INTEGER OPTIONAL[以字节为单位的重发分组长度]，

GPI_ARQ_WINDOWSIZE INTEGER OPTIONAL[用于GBN和选择性的重发窗口尺寸]，

GPI_HARQ GPI_HARQTYPE OPTIONAL[混合ARQ的设置]，

GPI_HARQ_CODE GPI_HARQCODETYPE OPTIONAL[混合ARQ编码的设置]，

--加密/解密设置-用于通用加密LLI

GPI_CRYPTO GPI_CRYPTOTYPE OPTIONAL[加密/解密的设置]，

GPI_CRYPTO_IV GPI_IV OPTIONAL[加密的初始化向量]，

GPI_CRYPTO_KEY GPI_KEY OPTIONAL[加密/解密的会话密钥]

GPI_PACKET∷＝SEQUENCE{

--通用数据分组(或帧)定义

--强制分组信息

GPI_PACKET GPI_PACKETTYPE[这是分组类型]，

GPI_PACKET_HEADER_PTR GPI_PACKET_HEADER[特定于协议的格式中的实际分组头]，

GPI_PACKET_PAYLOAD_PTR GPI_PACKET_PAYLOAD[特定于协议的格式中的实际分组有效负载]，

GPI_PACKET_HEADER_LEN INTEGER[以字节为单位的组头长度]，

GPI_PACKET_PAYLOAD_LEN INTEGER[以字节为单位的有效负载长度]，

--可选分组信息

GPI_TRCH GPI_TRCH_IDENT OPTIONAL[传送信道标识符]，

GPI_TF GPI_TFTYPE OPTIONAL[传送格式]，

GPI_DEST_MAC GPI_MAC_ADDRESS OPTIONAL[目的MAC地址]，

GPI_SRC_MAC GPI_MAC_ADDRESS OPTIONAL[源MAC地址]，

GPI_DEST_IP GPI_IP_ADDRESS OPTIONAL[目的IP地址]，

GPI_SRC_IP GPI_IP_ADDRESS OPTIONAL[源IP地址]，

GPI_DEST PORT INTEGER OPTIONAL[目的端口号]，

GPI_SRC_PORT INTEGER OPTIONAL[源端口号]，

GPI_SN INTEGER OPTIONAL[序列号]，

GPI_IP_HEADER_CHKSUMGPI_IP_HEADER_CHECK_SUM OPTIONAL[IP校验和]，

GPI_TRAFFICCLASS INTEGER OPTIONAL[传输类型的标识符]，

GPI_PACKETDIRECTION GPI_DIRECTION OPTIONAL(协议堆栈中的分组的方向]

各层中通用函数之间的映射和其执行环境中LLI调用的特定于操作系统的函数，可以用若干方式实现。参考图8，每个软件层(例如L2)包括若干预定的通用函数。假定L2层的厂商使用预定的通用函数，则这个层将与协议堆栈内的其它层互操作(interoperate)。支持协议堆栈的各层的执行环境与操作系统表(OS1)，或有效地将与各层相关的通用函数映射到将在该特定执行环境中执行通用函数的特定于操作系统的函数的其它对象相关联。在示出的例子中，L2中的通用函数1，例如receive_message，被转换为基于UNIX POSIX执行环境的等价函数。

操作系统表(OS)或映射对象可以由例如协议堆栈的操作方，或诸如执行环境提供方的某些其它实体来提供。

图9示出一种候选方案，其中软件层L2包括特定于该层的函数，其能够被操作系统表(OS2)或其它映射对象直接从其L2格式映射到本地操作系统格式。因而，例如L2函数1(对应于send_message)被操作系统表OS2映射到receive_message函数的本地基于UNIX POSIX的执行环境函数。在这个特定方案中，L2软件层的厂商可能也会提供针对UNIX操作系统环境的相应操作系统表OS2或映射对象。L2厂商可以能够针对不同类型的操作系统提供若干操作系统表，以便解释厂商提供的L2软件层。

图10示意性示出虚拟操作系统的使用(VOS)，其可以用于把通用函数调用引向适当操作系统-在示出的例子中为UNIX(OS1)或Microsoft Windows(RTM)(OS2)。因而，例如在不止一个操作系统或执行环境选项被用于驱动例如基站或终端的装置或设备上的普通协议层的情况下，VOS可以将通用函数调用从例如软件层L2引向UNIX或Microsoft Windows(RTM)操作系统表(OS1或OS2分别)或映射对象。在相同软件层的两个实例在不同操作环境中执行的情况下，VOS可以映射相同通用函数(例如通用函数1)到例如第一LLI的UNIX操作系统表(OS1)，以及第二LLI的Microsoft Windows(RTM)操作系统表(OS3)，其中相同通用函数分别相应到op.sys函数x及op.sys函数a。因为软件层L2正使用通用函数，L2的厂商只需要提供实际层软件(模块)，并且不需要参与VOS或操作系统表软件。VOS的操作在下面进一步更详细地描述。

现在参照图11，厂商提供的L2软件层包括特定于层的函数，所述函数接着被虚拟操作系统(VOS)映射，其中虚拟操作系统也可以由L2厂商提供，其可以使用特定于操作系统的表(OS2，OS4，OS5)或映射对象在不同操作系统之间映射特定于L2的函数，所述特定于操作系统的表(OS2，OS4，OS5)或映射对象也可以由L2厂商提供，以便分别映射特定于L2的函数到例如UNIX和Microsoft Windows(RTM)的相应操作系统函数。因而各种实施例可以被实现，以实现语言和/或操作系统无关的协议层软件。

图11还图解了例如均对应于不同LLI的两个线程怎样可以被映射到不同操作系统表，以便在不同执行环境中执行。线程1被特定于L2的函数(L2函数1)引向VOS表或映射中的特定项，并且于是被引向UNIX操作系统表OS2中的特定项，该项对应于可以在UNIX环境中执行的函数(op.sys.function.x)。线程1接着返回到在层L2模块中的下一个函数指针(L2函数2)。在不同实施例中，线程1可以被VOS引向Window的操作系统表OS4，以便在Window的环境中执行对应于层L2模块中的特定于L2的函数指针(L2函数1)的特定于Windows的函数(op.sys.function.a)。

线程2可以对应于相同层L2的不同LLI，该LLI在不同的Linux执行环境中执行。在这个情景中，特定于L2的函数指针(例如L2函数3)被映射到被执行的特定于Linux的函数(op.sys.function.m)，并且接着线程2返回到其在层L2模块中的下一个函数指针(L2函数4)。

图12示出在多个协议堆栈中层的多个实例。UMTS视频呼叫和两个WLAN因特网浏览器协议堆栈被同时示出为活跃的。因特网堆栈之一支持无限制的因特网浏览，而另一个堆栈支持浏览内部网，并且同样地必须支持加密(例如基于虚拟专用网VPN协议)。两个浏览器堆栈均具有4个被连接到WLAN的协议层实例(分别为L4₁-L1₁，和L4₂-L1₂)，然而层2实例(L2₁和L2₂)均被不同地配置在每个堆栈中。这由在因特网堆栈中、指示支持加密的层2的第二实例的L2₂(sec)，以及在因特网堆栈中、指示不支持加密的层次2的第一实例的L2₁(non-sec)来图解。这些配置将由发送到这个层的每个实例(L2₁和L2₂)的原始绑定消息来确定。两个浏览器堆栈的层1，3和4相同，并且包含单独(各为L1₁，L3₁，L4₁，以及L1₂，L3₂，L4₂)但相同配置的相应层的实例。

用于执行安全堆栈层实例的执行环境可以配置为阻止非安全实例对消息或配置数据的任何可能的访问。例如，这可以通过使用操作系统函数表实现，其中操作系统函数表执行所有存储器访问和消息传送操作的授权，以使它们与安全堆栈实例隔离。例如，通过VOS和/或操作系统映射对象提供方希望函数做什么，确定send_message函数的底层实现。因此，如果例如软件层是不可信的，则在send_message和receive_message函数中执行的功能将具有更多有意识的安全性。例如这可以包含连接到基本检索数据函数的授权函数。在其它例子中，create_LLT函数产生具有其自身存储器区域的分立进程，以保证没有可能存在能够访问由可信软件模块使用的存储器的层。如果认为操作系统自身不够可信，则它甚至可以在分立操作系统环境中执行。

每个层也可以用不同性能优化来实现，例如为执行高强度加密操作的堆栈实例提供优先。

层2的(L2₂)的第二LLI使用相同代码模块(层2)作为第一LLI(L2₁)，但是是新逻辑实体(在这种情况下，操作系统执行线程或进程)，而不是载入工作存储器的代码模块的其它拷贝。例如，第二LLI(L2₂)可以是在这个代码模块内的第二执行线程，其中第二线程由操作系统控制并且具有其自身的唯一标识符和相关配置。这个配置信息只可被逻辑层的该LLI(例如线程)，以及设置每个实例的配置的控制实体(在下面更详细地描述的CM)访问。LLI之间的交互还由CM来配置，并且可以阻止不需要交互的LLI进行交互(通过执行环境配置措施)。

此外，尽管层2的两个LLI(L2₁和L2₂)支持公共功能，然而它们可以被不同地配置。在这个例子中，L2₂支持加密/解密，而L2₁不支持。这些配置设置由绑定消息设置，并且可以被存储在堆栈或工作存储器的表中与每个实例(LLI)相关的适当位置。

层2软件的第二LLI会具有不同LLI标识符[instance.ref]，以及将其链接到不同输出层的不同绑定引用[bind.ref]。由[function.ref]标识的操作系统函数表(或操作系统类)可以是如层2的第一LLI所使用的相同操作系统表，除非其在不同执行环境中工作，在这种情况下它将需要不同的操作系统函数表，以将通用函数映射到在其相应执行环境内执行这些函数所需的特定于操作系统的函数。第二LLI也可以具有其自身的执行堆栈(L2₂堆栈)和堆存储器。每个LLI会具有相同的可用配置选项，不过可以不同地使能/禁止这些。这些可以作为参数存储在其相应LLI配置中。

每个层会使用预定的通用函数调用，这些调用会包含线程管理以及存储器管理函数。接着在运行时刻这些函数被映射到目的设备上的特定于操作系统的函数的组。由不止一个LLI访问的数据(诸如操作系统函数表和信号分组)被以预定格式提供，该预定格式允许每个LLI使用预定函数调用组访问这个信息。

绑定信号[bind.para]可以在任何时候被LLI接收，包含在原始绑定信号之后，并且因而允许LLI的配置选项被改变，并且此外允许LLI通过改变bind.ref参数而被绑定到另一个LLI，因而允许动态重新绑定协议堆栈。

协议层的LLI可以通过实例化操作系统线程来产生，该操作系统线程具有其自身的执行堆栈，以提供一定程度的控制和与其它执行线程的隔离(例如能够在不同线程之间终止和提供基于优先级的多任务)。可选地，不同LLI可以被实例化成不同操作系统进程，以通过为每个进程提供其自身的存储器堆并阻止其它LLI的访问，提供更高程度的隔离和控制。然而，这在执行基于优先级的多任务(即与线程相对的进程之间的上下文切换)时导致增加管理开销的代价。最后，可以在相同的操作系统线程内实例化LLI。这样的好处是，在建立和控制LLI方面存在最小管理开销，但是不存在分立栈或堆，因此如果依赖操作系统安全措施，则对数据(诸如LLI配置)的访问和对其执行的控制(即划分优先级(prioritisation)等)会很大程度上依赖父线程。在后者的情况下，如果LLI使用的编程语言和执行环境与其父线程相同，则是优选的，但是这不是强制的。

除上述操作系统执行环境之外，也可以在诸如FPGA或DSP的外部可编程设备中实例化LLI。这些执行环境与在相同操作系统的控制下在单(或多)处理器方案内的环境非常不同。然而，虚拟操作系统函数表(VOS)能够允许从在不同设备上实现LLI的软件模块抽象出设备间通信复杂性。

通过上述方式，可以在不同执行环境中使用不同执行线程或进程产生多个逻辑层实例。此外，每个LLI可以用不同协议特性(配置选项)来配置，但是可以使用公共数据访问机构访问信号消息数据和其它共享数据。当如上所述不止一个LLI在相同线程内产生时，出现一种特殊情况。

如已经讨论的，可以在不同执行环境中执行(相同或不同)协议堆栈层的不同LLI，以提供不同层次的安全性以及性能。例如，蓝牙堆栈可以支持安全高速连接和非安全低速连接。处理安全高速连接的LLI的执行环境可以针对安全性和性能而优化，并且支持低速连接的LLI可以在较低安全性和较少优化的执行环境中得到支持。

这个方案限制LLI之间的交互并且在对每个LLI必要时(具有适当安全措施)使用不同执行环境适当隔离它们。通过这种方式，高度可信软件可以被允许有更大自由，并且可以在没有执行严格运行时刻安全性检查或没有限制功能的更加优化的执行环境中执行，而在对与其它LLI进行的允许交互有更多限制的环境中执行使用较低可信软件的LLI。这些措施还将不仅依赖于软件内的可信等级，还依赖于涉及LLI支持的服务的类型的完整性和其它安全性要求(诸如隐私和保密)。

图13图解了建立和升级情景，用于实例化各层并且用于绑定一个软件层到例如蜂窝电话中的另一个软件层。电话存储或下载若干软件代码模块，这些软件代码模块被直接(即天然地)或者使用虚拟机环境机构(诸如Java类加载原理)及标识的入口点载入工作存储器。在示出的例子中，其包含层1-3及配置管理器(CM)，配置管理器通过加载对应于软件层的代码模块到工作存储器中，调用入口点并发送适当绑定消息以配置或重新配置各层，从而控制协议堆栈的结构。例如发送到层1的绑定消息指示它“绑定”到层2。

在层2被层2′替代的升级情景中，层2′软件层文件或代码模块被载入工作存储器(L2′)，并且配置管理器(CM)调用新层的层入口点。它接着发出绑定消息到层2′，以传送其输出到层3并且设置适当协议选项。配置管理器还传送绑定消息到层1以重定向其输出从层2到层2′。这个升级重新配置在运行时刻发生，并且只需要实现相对简单的绑定消息。它还允许经过(旧)层2(L2)的任何分组继续得到处理并且传递到层3(L3)，使得相关会话不被动态重新配置终止。因而在堆栈重新配置期间不需要会话终止，其中假定新实例访问旧实例的配置(包含状态)数据。

参考图14，例如为实例化层2的第一实例(L2₁)，配置管理器(CM)加载层2代码模块到工作存储器(或虚拟机环境)的程序代码区。接着，通过在本地(native)软件模块的情况下直接调用工作存储器中的代码入口点(层入口点)，或在虚拟机环境中调用层入口点成员函数(运行方法)，配置管理器启动LLI。

CM调用加载过程，并且因此对于Java，意味着加载类文件，并且对于本地层，意味着以适于执行环境的方式加载部分代码到存储器。因为CM知道执行环境，它知道加载模块，和传递默认适当VOS和/或操作系统表(OS)的方式。在下面更详细地描述这些例子。在本地代码层中，这需要通过定位和执行入口点函数来调用入口点。入口点函数需要具有允许接收绑定消息的默认行为。例如，在Java类中，这可以调用加载默认VOS和/或特定于操作系统的类到JVM中，以便能够接着调用receive_message函数。在本地层中，入口点可以包含参数，即指向默认VOS和/或特定于操作系统的(OS)表的指针。一旦模块入口点被初始化(例如可以调用VOS或OS表的拷贝并且分配一些工作或堆存储器)，则它调用VOS(或操作系统函数表)中的receive_message函数并且接着不做任何事情，直到绑定消息被接收。

如上所述的初始化函数只是获取默认VOS(或操作系统)表，在必要时对其进行拷贝(或指向其在共享存储器中的位置)并且调用receive_message函数的启动引导方法。

receive_message函数在VOS或操作系统表(OS)中，并且因此VOS或OS确定消息怎样被发送(通过函数调用或者操作系统线程消息传送等)。绑定消息是特定消息类型的(全部消息具有唯一标识符以允许确定消息类型)。因此，其它消息(除通常强制清理退出的终止消息外)在等待绑定消息时被忽略。

绑定处理程序简单地调用create_new_LLI，它也是可以调用新线程或进程实例，或实际上可以不进行这些而仅修改LLI表的VOS或OS函数。然而，来自绑定消息的配置信息被传递到create_new_LLI函数以便允许针对该LLI设置配置。这包含对将由LLI使用的特定VOS和/或OS表的引用。这可能不同于由初始化函数复制或使用的VOS和/或OS表，例如如果层需要传递协议消息到不同执行环境中的层。新线程调用特定VOS(或操作系统表)内的receive_message函数以等待要处理的消息。

如上所述，绑定消息包含交互或接口信息以传送层的输出到下一层。绑定消息也可以包括必要函数调用以做这个(函数表)。例如，根据针对相关LLI选择的配置选项和/或其执行环境，函数或函数指针的初始化模板可以被传递到模块入口点，而处理函数的更特定模板可以通过绑定消息被传递到模块。CM则可以指示特定于执行环境的安全机构允许从新LLI到允许的其它LLI的交互，并且可以可选地在共享配置数据上设置访问控制机构以允许只访问由新LLI允许的部分配置数据。

绑定消息配置选项可以通过使用针对安全性，性能和功耗的通用配置偏好来确定要启用的特性，例如是否启用层内加密。如果多个协议堆栈实例被同时使用，则每个层可以有多个LLI，并且用唯一实例标识符(instance.ref)标识这些。相同层的不同LLI可以具有不同配置，其中一些支持加密，而一些不支持。

以不考虑实现的特定细节的通用方式支持入口点调用和参数传递。优选地，ANSI标准C(也称作Cdecl)约定被用于传递本地软件模块的参数，例如(function.pointer)或(start.pointer)，到入口点，该入口点提供诸如线程建立的执行环境相关函数以及消息相关函数(包含配置数据访问函数)。然而，对于Java层，软件层的Java类扩展了线程Java类，并且当层被载入JVM时自动调用运行方法。如果本地层入口点被调用以实例化新线程，则在新执行线程中产生新实例并且入口点返回。

可选地，(尤其当各层在虚拟机环境中执行时，但不限于这些层)可以在伴随层软件模块的声明(manifest)(元)信息文件中指示入口点类(或位置)。当绑定消息被处理时，使用create_new_LLI产生新实例线程，并且新实例线程现在使用receive_message函数等待协议消息。

每个层实例配置数据将包含涉及下一个层实例的信息以发送分组或协议消息，诸如[signal.pointer]。因而，当层要求发送分组(包含在协议消息内)到下一个层时，针对绑定引用(bind.ref)的get_attribute函数被用于根据LLI配置数据获得发送消息到的下一个层实例。

当实例化相同层的多个LLI时，绑定处理程序将针对新层实例(L2₂堆栈中)用配置数据形成新实例。先前所述的配置数据将包含实例的唯一标识符，并且一旦已经产生新线程实例，则返回确认到CM，CM则可以设置适当执行环境安全措施。绑定消息可以被CM直接发送到LLI以改变实例的配置。

如前所述，传入绑定消息包括实例号[instance.ref]。绑定引用[bind.ref]标识在应当传送输出协议消息到的当前LLI之上的层的LLI。函数指针[function.pointers]标识适合于特定LLI的操作系统函数表(OS及可能VOS)，使得当层调用预定数量的函数之一(例如“create_new_LLI”)时，函数指针指向适当位置和存储器，其包含针对LLI所工作的特定执行环境或操作系统而正确格式化的针对这个函数的函数调用。换句话说，操作系统函数表映射LLI内的“通用”函数调用到由操作系统使用的语言和操作系统相关函数，以执行这些函数。函数表通常会包含存储器访问和管理函数，其包含访问信号分组或在层之间传递的其它消息。因而，例如层1可以使用操作系统函数send_message传递信号分组(针对signal_packet_2)指针[signal.pointer]到层2内的LLI。这允许层2LLI基于其内部协议函数，使用由操作系统函数表提供的函数，并且使用其自身LLI执行堆栈(L2₁堆栈)访问这个特定信号分组并且进一步处理它。

如上所述，公共平台无关的虚拟操作系统(VOS)函数表可以被用以提供对执行环境函数和LLI配置信息的访问。这提高了执行环境(操作系统和虚拟机)无关性，并且在图15中被图解。其中示出了5个层(L1-L4)，包含“旧”层3(L3)以及升级层3(L3′)。示出的层的两个(L3′和L4)在Java虚拟机(JVM)内操作。JVM需要解释器或虚拟机环境以实时解释对应于这些层的软件模块的代码，并且还提供本地接口(NI)，用于与非Java软件接口。其它层(L1-L3)被预编译成目标代码并且在运行时间由操作系统本地执行。

还允许提供如图所示的多个执行环境，其中操作系统1和操作系统2均执行不同层，但是各层仍然可以互相通信。

使用操作系统函数表(OS)把层中的通用函数调用转换为实际特定于操作系统的函数。在VOS情况下，需要进一步转换或映射。每个到LLI的绑定消息向VOS函数表提供函数指针，其中VOS函数表自身指向OS的特定于操作系统的函数以允许各层执行。这提供操作系统无关性，因为VOS函数表可以被重新指向不同特的定于操作系统的函数。例如，CM可以指示LLI(通过绑定消息)在运行时刻动态改变其对应于由LLI使用的通用函数的特定于操作系统的函数的VOS表，其中从例如基于UNIX的POSIX函数(OSx)改变到基于UNIX的系统V操作系统函数(OSy)。然而动态改变需要考虑到某些操作特定函数包含或改变涉及系统状态的信息(尤其是信号量和其他类似于存储器分配的系统资源处理函数)的情况，因此，VOS概念可以通过在这些间接寻址机构内提供智能和操作系统抽象来允许必要时在OS环境之间无缝切换的能力。它还允许软件代码模块以能够支持不同执行环境的最通用方式来编写。

在协议软件中，串操作不经常执行，然而类似于“calculate_crc”或“convert_ip_address_2_string”的任何频繁操作可以被包含作为在操作系统表(OS)或VOS表中具有相应操作特定函数的通用函数。在可选方案中，诸如加密与解密的某个信号数据操作函数在通用加密/解密层中实现，该层可以被配置为执行不同加密与解密操作。这是包含最数学化的函数的层，并且可以使用(在必要时)具有数学扩展的VOS或操作系统表(OS)，因为它可以在具有这些复杂数学函数的性能加速器的执行环境(类似协处理器)中操作。接着其它或通用协议层将使用没有这些扩展的通用VOS或操作系统表(OS)。

用来以执行环境和语言无关的方式将函数指针传递到模块的方法在图16和17中被图解。具体示出本地代码例子，例如C，其中图16示出已知动态链接方法，并且图17示出基于实施例的传递函数表指针的方法。

参考图16，软件模块的厂商开发包括一系列API函数(x和y)和变量的源代码程序(在这个例子中用C编程语言)，以与存储在目标平台(硬件，函数库集合，以及诸如输入/输出的操作系统函数)的存储器中的数据，以及可能地在平台上操作的其它API库模块进行交互。源代码被已知编译器编译成目标代码，其转换系列函数成特定于目标平台的二进制机器(或对象)代码。二进制代码包括一系列位置标志符或符号(符号X和符号Y)，其均对应于API库模块中的系列函数(x和y)之一。

当对象代码被载入目标平台上的存储器以执行时，在预先加载的对应于库源代码中的函数(分别为x和y)的API库模块中，动态链接程序检查代码，并且用API库函数(mem.loc(X)和mem.loc(Y))的存储器位置替换系列符号(符号X和符号Y)。如果库模块未被加载，则它可以被动态链接程序(或类加载器，在基于Java的实现的情况下)动态加载。接着，通过使程序计数器逐步扫过包含程序指令的存储器位置系列并且跳转(分支转移)到对应于软件模块所需的API库函数调用(mem.loc(x)，mem.loc(y))的存储器位置，平台可以执行代码。

参考图17，被加载在目标平台上的软件模块的厂商(C程序员)开发出源代码程序，该源代码程序包括对应于在图16的方案中使用实际API函数调用的位置的一系列API函数调用(redirect.f(x)和redirect.f(y))。重定向函数只是重定向函数调用到指定VOS或OS函数指针表内的特定项的存储器位置(在阵列内堆或共享存储器中的在编译时未知的位置保存)。C源代码被编译器编译成目标代码，该目标代码也包括二进制机器码，然而在源代码中不存在对应于函数的符号(X和Y)。而是简单地将重定向函数编译成到存储器位置的跳转(或分支转移)指令，该存储器位置保存在存储器驻留函数表内的一个项(每个项对应于一个API函数)中，该存储器驻留函数表在运行时刻被加载在目标平台上。

通过这种方式，多个执行线程可以在不需要动态重新链接软件模块的情况下使用不同API实现代码来运行软件模块。

编译器转换重定向函数为相对存储器指针，其在运行时刻相对于OS或VOS表的起始处，并且因此指向由目标代码指示的特定于执行环境的适当函数。在这种情况下，源代码需要使用重定向函数而不是图16的API型函数来编写。

在可选方案中，现有技术源代码程序被修改的编译器转换成相同目标代码，编译器转换C特定函数(例如函数x)成重定向函数调用redirect.f(x)，以允许使用(在运行时刻动态加载的)函数表。

当这个软件模块目标代码被载入存储器时，它被传递针对对应于在堆或共享存储器的位置的特定于平台的映射表的引用(诸如存储器中的起始地址)。默认函数指针表可以被加载在预定相对存储器位置处，对于目标代码，其中软件模块不包含入口点函数或其它装置的实例也可以通过表引用指针来传递。

于是平台可以通过运行该系列指令来执行这个目标代码，其中该系列指令被从重定向(跳转或分支转移)程序计数器的redirect.f(x)编译为存储器值对应表项(redirect.f(x))，其是平台上实际OS或VOS库函数(mem.loc(x))的存储器位置。函数被执行并且程序计数器返回到软件模块目标代码中发生跳转(或分支转移)的位置。

可以发现，这允许被编译成位置无关代码(即可以从任何存储器地址执行的代码)的可加载软件模块是平台无关的，这意味着平台(操作系统，动态链接程序或Java虚拟机)不需要知道软件模块代码的具体语言和语义，以及它怎样与其它模块交互。也可以发现，源代码可以是语言无关的，由于所编译的目标代码包含指向映射表而不是预定符号的相同指针，动态加载器将需要解释该指针并且用针对平台特定函数的存储器位置替换该指针。例如，用C，VisualBasic或Pascal编写的程序将均被编译成具有相对函数指针的相同目标代码，其传递特定于执行环境的函数所位于的存储器中的起始点，相对指针指示相距这个起始点的相应函数的相对位置。这允许厂商提供可以用任何语言编写的软件模块(目标代码)，并且其是平台无关的。

最后，执行软件模块代码的每个线程或进程可以使用不同库函数表映射这样做，以允许相同代码段的行为具有完全不同的实现库函数的方式。因此，一个执行线程(在存储器驻留二进制或字节代码模块上)可以调用实现库函数的轻量(lightweight)集以优化性能的库函数，并且另一个执行线程(相同存储器驻留代码的)可以使用重量(heavyweight)库函数实现以优化例如安全性。

参考图18和19，针对基于Java语言的层程序分别示出动态链接(类加载器)和函数指针传递方法。本地和Java软件模块之间的主要差异是在Java中，间接寻址的额外层被引入以横贯在Java和本地软件模块之间。Java软件模块具有分别对应于本地库函数Java_class_redirect.f(x)和Java_class_redirect.f(y)的Java本地接口方法redirect.m(x)和redirect.m(y)。Java本地接口方法被类加载器映射到本地函数。通常，当使用标准JVM类加载器时，本地库模块必须使用System.LoadLibrary方法来加载。然而，也可以产生可以使用其它方法加载类和库的定制Java类加载器。

接着，类加载器会在这个例子中解析在Java本地接口类(mem.loc(redirect.f(x))和mem.loc(redirect.f(y)))中使用的本地符号。这些重定向函数会接着用和本地重定向函数同样的方式操作，并且使用映射表以重定向函数调用到实函数mem.loc(x)和mem.loc(y)。

可以定制Java类加载器以消除加载本地接口库的这个中间步骤，因为这显然以特定于平台的方式执行，并且需要每个平台具有相应接口库组，以允许实际本地API库被访问。

图20图解了针对协议堆栈的实现的按照消息的线程的解决方案。在这个方案中，线程与整个协议堆栈中的每个分组或信号相关。在示出的例子中，thread_signal 1与堆栈实例内层1处理的协议消息信号1相关，接着继续到其中由各种函数或示出的子模块处理消息的层2(图14中代码块或模块的分组或协议消息处理部分)，并且执行继续到其中进一步处理消息的层3。类似地，thread_signal 2与协议消息信号2相关，该协议消息信号2被传送通过层1并且到达层2，在层2中在示出特定时间点处，其到达层2的“校验和”子函数。这个方案类似于现有提出的框架，然而它的缺点是，具有由大多数多任务操作系统提供的不同安全性和性能配置的不同执行环境不能容易地用于区分不同LLI，而是需要实现可以基于LLI根据需要抢占线程的定制调度器。

累积函数在虚线轮廓中示出，并且未在上面描述以方便说明。当在按照消息的线程的方案中实现累积函数时，存在两个可能实现。一个实现是简单地终止线程，然而这依赖于监视缓冲区以便伺服缓冲的分组的另一个线程。可选的实现是返回到调用函数，并且接着执行线程可以被用于处理另一个消息。这比终止线程更有吸引力，因为线程产生等待时间和管理开销在操作系统上会非常高，除非实现非常轻量的线程模型。

这示意性地在图21中示出，其中在工作存储器中示出两个代码块2，和通过这些代码块与各种执行线程相关的执行堆栈，以及堆和其它共享存储器对象。各种执行堆栈将存储各种参数，例如微处理器寄存器的当前状态，函数和代码模块内的静态数据，以及用于函数调用参数传递的参数。调度器和线程管理器以已知方式控制各种线程的操作，将当前或活动线程的相应堆栈的适当内容载入微处理器寄存器，并且在刚切换(称为上下文切换)的线程的适当堆栈中存储寄存器的内容。例如可以发现，在代码(TS1)的L2模块中thread_signal 1的执行点比thread_signal 2(TS2)进一步经过更多的代码，其中(TS1)和(TS2)表示每个线程的程序计数器值，并且因此指示代码模块中该线程的下一个执行点。各种其它执行堆栈将与传递经过协议堆栈的各代码块L1-L5的其它信号相关。可以发现，每个线程与单个信号相关，并且以同步方式“跟随信号”通过协议堆栈。

如图22所示，相比之下另一个实施例使用按照LLI的线程。Thread_layer2_LLI#_1对应于从低层(例如层1)接收了信号或分组(协议消息)的层2或代码模块内的一个线程。该线程通过该层的各种子函数处理此信号，并且传递所处理的输出(信号，分组或消息)到高层(例如层3)。它接着返回到其相关的层2的接收消息或输入函数，准备好处理下一个协议消息。类似地，thread_layer2_LLI2与和第一线程相同的层(层2)中的、但是在不同实例或LLI中的单独分组或协议消息相关。在示出时间点处，这个第二线程或执行点已经到达层2的解密子函数。一旦每个线程通过其LLI处理了协议消息，则它返回到空闲状态并且调用receive_message操作系统函数以等待来自低层的新分组。在LLI之间传递的消息由执行环境处理，当执行LLI的执行环境驻留在不同物理处理器上时，可能使用来自所涉及的任一LLI的不同操作系统线程或进程(例如thread_send_message(x))。receive_message函数简单地等待和取得预定消息队列中的消息。类似地，send_message函数把消息放在预定消息队列中。

这个按照LLI的线程(thread-per-LLI)的方案胜过先前方案的优点是，每个LLI可以被配置成以不同优先级(如果适当)在不同执行环境(在必要时)中操作，并且采取不同安全措施以阻止任何不良行为的软件模块影响其它LLI的操作。

累积函数已经在虚线轮廓中示出以简化最初的说明，然而由于针对协议堆栈的这种方案本身在性质上是异步行为的(即具有消息的累积)，则使用异步消息传递有吸引力，其使得消息(分组)被以发送方和接收方可访问的公共和永久方式缓冲。如果在层代码内自然地执行累积(如在按照消息的线程方案中那样)，则消息数据必须从发送方被复制到累积缓冲区，并且接着再次从缓冲区复制到下一个层。

通过具有永久共享存储器队列，允许消息被投送到队列，而不需要任何数据拷贝。协议堆栈实现中的拷贝应当被最小化以获取良好性能。因此，如果send_message函数简单地将针对消息的指针放到接收方消息队列中，则根本不存在任何数据拷，贝并且接收方仍然可以用相同方式访问数据。其它优点是，当一个层实例LLI被重新配置(即替换)成另一个LLI时，则队列仍然在那里，并且消息数据仍然在那里，并且因此什么也没有丢失，并且处理可以继续，就好象什么都未发生。

另一个优点是，当在堆栈中升级或替换LLI期间，由未被升级的LLI处理的协议消息(信号)不受影响。并且，在必要时，预先执行的切换可以通过重定向针对旧实例的分组到将由新实例使用的队列，或通过挂起旧实例来实现(并且因而阻止旧版本的进一步处理，但没有丢弃分组)。这是可能的，例如如果使用永久共享存储器排队来实现send_message和receive_message函数，并且队列可以由在新LLI的实例化之前向新LLI版本实例下面和上面的LLI实例发送绑定消息的CM来重新关联，因为分组将开始被排队以准备用于新LLI实例。这个方法有吸引力，因为新LLI的实例化会是消耗时间的，并且如果例如切换是从非安全到安全LLI版本，则以非安全方式继续的分组处理会在系统中暴露易受攻击性。

图23示出类似于图21的按照消息的线程的方案的示意图，但是示出对应于按照实例的线程的方案的执行堆栈。例如，示出与层2代码模块相关的两个线程，然而每个线程关联于L2的不同实例(LLI)，这与L2内的不同协议消息相反。(TL2₁)，(TL2₂)和(TL1₁)图解了程序计数器数值或每个LLI线程在代码模块中的位置。

图24和25图解了到达在实施例中应用程序的代码模块的不同路线。在图24中，厂商开发C++源代码程序，该C++源代码程序被转换源代码到通用执行代码模块格式的“源到指针”编译器编译，该格式在函数模板中包括对应于通用函数的一系列指针。指针具有如前所述的公共数据格式，并且是针对OS表或对象中的相应特定于操作系统的函数的相对存储器指针。例如，第一通用函数(例如Func#1，即create_new_LLI)对应于OS中的第一特定于操作系统的函数。在知道存储器中相应OS的位置的情况下，当执行环境执行模块时，执行环境被指向OS中适当格式化的特定于执行环境的函数。

在图25示出的可选方案中，厂商开发相同C++源代码程序，该C++源代码程序被标准C++编译器编译成特定于平台的C++代码模块。接着需要另一个编译器，以便把这个模块转换成上述通用函数指针代码模块，并且其适于使用OS(以及在某些实施例中的VOS)来执行。

图26示出使用一些上述实施例的实现例子。具有蓝牙能力的终端设备在本地语言软件层(软件层#1及#2)内运行标准蓝牙协议堆栈。蓝牙堆栈使用上述绑定功能，上述绑定功能使平台操作系统和语言无关协议层能够动态链接到一起。示出的两个协议堆栈实例(Instance#1和Instance#2)可以被配置为提供不同蓝牙服务。例如，LAN访问简表实例和IP语音或蓝牙网络封装简表实例。LAN访问简表接着被用于使用专用蓝牙接入点执行Web浏览，并且同时IP语音简表被用于通过相同接入点进行电话呼叫。

可以通过使用如图27所示下载Java层(层#3)增加对新简表的支持来定制蓝牙堆栈。这个层提供(例如)增强的安全性或性能或新服务功能。Java层被动态加载和新的层实例(LLI#1和LLI#2)，其被绑定到现有本地语言蓝牙堆栈，但不需要通过所使用的实施例重新启动蓝牙堆栈。因此，现有蓝牙连接会话未被破坏。新层可以被用于实例化用于加密和解密终端和接入点之间的数据的增强安全性简表。

为支持操作系统无关性，使用在协议堆栈内用于与协议堆栈内的其它模块交互的所需特定于平台的函数的操作系统函数表(例如允许共享存储器分配和线程消息传送等的函数)。绑定消息还将确定允许哪些其它模块与它交互，并且执行环境机构将存在以验证这些资源的真实性。绑定消息还必须包含协议层所需的所有必要初始配置数据。

使用不同执行线程实例化这个蓝牙堆栈内的层，并且每个层利用VOS或OS receive_message和send_message分别作为协议消息入口和出口点，以允许VOS或OS实现适于LLI的选定执行环境的交互机构。线程或进程可以通过唯一LLI名被标识，唯一LLI名包括唯一层名(在这种情况下为“蓝牙堆栈层#3”)和层实例标识符(在这种情况下为“LLI#1”和“LLI#2”)。通过这种方式，线程名被用于唯一标识层实例。VOS和OS可以使用特定于操作系统的机构以支持LLI之间的交互，和LLI线程和进程的调度，或者也可以使用专有及高度优化的机构。这可以根据安全性，性能或甚至根据诸如存储器和功耗的资源利用来优化。

这个方法允许用不同配置产生LLI。在绑定处理期间用绑定信号配置每个LLI，其中绑定信号不仅标识LLI与之通信的其它LLI通信，而且标识用于具体实例的配置数据。

VOS支持的LLI消息队列可以被保存在永久共享存储器中，以允许在协议堆栈仍然活动的同时动态升级软件。也可以进行LLI的重新绑定以允许插入层到活动协议堆栈中。

配置新层(蓝牙堆栈层#3)到协议堆栈的处理如下：

1.第一步是通过调用相关模块入口点来开始执行“蓝牙堆栈层#3”。就Java模块来说，类文件被载入由CM选择的JVM环境。如果珲没被加载，则模块加载默认VOS或OS API。接着运行方法自动被JVM调用，并且层软件(模块)调用load_template函数以便随后能够访问配置和消息数据，并且调用receive_message函数以等待绑定消息。

2.绑定消息被传递到具有必要配置信息的“蓝牙堆栈层#3”线程。接着线程通过调用VOS或OS create_new_LLI函数产生新LLI实例。在新LLI内，特定于LLI的VOS和/或OS表在必要时被加载。产生线程“蓝牙堆栈层#3实例#1”，并且回送OK响应。新LLI执行通用load_template函数(如果需要不同模板)以允许访问消息和配置数据，并且接着调用receive_message以便等待下一个消息。

3.重新绑定请求消息被送到“蓝牙堆栈层#2实例#1”，其中“蓝牙堆栈层#2实例#1”用OK消息响应该消息以确认重新绑定，并且最初指定到“主因特网堆栈”的所有后续分组现在被发送到“蓝牙堆栈层#2LLI#1”。

4.重绑定消息被送到“主因特网堆栈”，更新路由表并且接收OK响应。

5.LLI#1现在是活动的，相同过程被重复用于层#3 LLI#2。

为了使Java蓝牙堆栈层#3可以容易地与本地语言蓝牙堆栈层#2及主因特网堆栈互操作，使用上述公共的VOS和/或OS支持的机构，其用于交互和线程与进程调度。用于以平台无关的方式访问这个公共功能的方法依靠动态可加载VOS和/或OS函数库。

当“蓝牙堆栈层#3”线程在JVM环境内被实例化时，进行Java调用以加载默认VOS和/或OS库。VOS和/或OS库包含一组涉及系统资源的处理函数。这些最少包含：

·信号和存储器分配函数

·线程产生(和销毁)函数

·消息发送和接收函数

·配置和信号数据访问函数

VOS和/或OS函数库接着被用于与其它LLI通信，以及访问配置数据(使用适当的加载的模板)。可以在若干不同操作系统上支持通用LLI和VOS函数，并且可以从许多不同语言和虚拟机环境访问通用LLI和VOS函数。函数库还提供对消息队列，信号和配置数据的受控访问。例如，函数库可以基于LLI标识符限制对配置数据的访问，以及把消息发送和接收的使用控制到适当授权的源和目的。通过这种方式，产生安全的语言和操作系统无关的协议堆栈执行环境。

通过这种方式，可以使用某组加密功能设置产生例如“蓝牙堆栈层#3 LLI#1”。这些设置可以在“蓝牙堆栈层#3 LLI#2”中是不同的，并且在用于绑定处理的绑定消息中被定义。接着，LLI#2不可访问LLI#1的参数，并且反之亦然，以及LLI#1也不可截取针对LLI#2的分组，并且反之亦然。

本领域技术人员会认识到，上述设备和方法可以被体现为例如磁盘，CD-ROM或DVD-ROM的承载介质，诸如只读存储器(固件)的编程存储器，或诸如光或电信号载体的数据载体上的处理器控制代码。针对许多应用，本发明的实施例会在DSP(数字信号处理器)，ASIC(专用集成电路)或FPGA(现场可编程门阵列)上实现。因而代码可以包括常规程序代码或微码，或例如用于设置或控制ASIC或FPGA的代码。代码也可以包括用于动态配置诸如可再编程逻辑门阵列的可重新配置设备的代码。类似地，代码可以包括用于诸如Verilog^TM或VHDL(超高速集成电路硬件描述语言)的硬件描述语言的代码。本领域技术人员会理解，可以在彼此通信的多个连接的部件之间分配代码。如果适当，也可使用现场可(重新)编程模拟阵列或类似器件上运行的代码来实现实施例，以便配置模拟硬件。

本领域技术人员还会理解，各种实施例和针对其描述的具体特性通常根据上述教导可以自由地与其它实施例或其具体描述的特性相结合。本领域技术人员还会认识到，在不偏离所附权利要求书的范围的情况下，可以对所描述的特定例子进行各种变更和修改。

Claims (60)

1.一种提供用于在处理设备中处理信号的通信协议的方法，该处理设备具有处理器和存储器，该协议由多个协议层定义；该方法包括：

加载软件模块到存储器中，该模块被设置成基于对应于所述层之一的一组通用函数接收和处理所述信号，该模块在函数映射对象中包括对应于所述通用函数的通用函数指针；

加载所述函数映射对象到存储器中，该对象包括对应于通用函数的特定于设备的函数指针，以便把所述通用函数映射到一或多个特定于设备的函数；

基于所述映射的特定于设备的函数执行该模块，以便基于所述协议层处理所接收信号。

2.如权利要求1所述的方法，其中该模块被设置成与其它模块交换对应于所述信号的协议消息，所述其它模块被设置成基于对应于其它所述层的一组通用函数处理所述信号。

3.如权利要求2所述的方法，还包括：

加载所述其它软件模块到存储器中，所述其它模块在函数映射对象中包括对应于所述通用函数的通用函数指针；

针对每个其它模块，加载所述函数映射对象到存储器中，该对象包括对应于通用函数的特定于设备的函数指针，以便把所述通用函数映射到一或多个特定于设备的函数；

基于所述映射的特定于设备的函数执行所述其它模块，以便基于所述协议层处理所接收信号。

4.如权利要求2或3所述的方法，还包括接收包括另一所述模块的标识符的绑定消息的所述或每个加载的软件模块，其中第一模块被设置成与由所述绑定消息标识的其它模块交换协议消息。

5.如权利要求2到4中任意一个所述的方法，其中模块具有用于处理所述协议消息的不同配置选项。

6.如权利要求5所述的方法，其中所述绑定消息包括用于确定在所述模块的执行中实现哪个所述配置选项的标识符。

7.如权利要求1到6中任意一个所述的方法，其中协议消息，绑定消息和通用函数指针具有公共通用格式。

8.如权利要求1到7中任意一个所述的方法，还包括：

加载第二软件模块到存储器中，该第二模块被设置成基于对应于所述层中的第二层的一组通用函数接收和处理所述信号，该第二模块在第二函数映射对象中包括对应于所述通用函数的通用函数指针；

加载所述第二函数映射对象到存储器中，该对象包括对应于通用函数的第二特定于设备的函数指针，以便把所述通用函数映射到一或多个第二特定于设备的函数；

基于所述映射的第二特定于设备的函数执行该第二模块，以便基于所述协议层处理所接收信号；使得第一和第二模块在不同执行或特定于设备的环境中被执行。

9.如权利要求1到8中任意一个所述的方法，其中所述模块是语言无关的。

10.如权利要求9所述的方法，还包括提供高级软件语言代码，用于基于对应于所述层的所述一组通用函数处理所述信号；以及将所述代码编译成所述语言无关的软件模块。

11.如权利要求1到10中任意一个所述的方法，还包括基于所述映射的特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供所述模块的2个逻辑实例。

12.如权利要求1到11中任意一个所述的方法，还包括：

加载所述第二函数映射对象到存储器中，该对象包括对应于通用函数的第二特定于设备的函数指针以便把所述通用函数映射到一或多个第二特定于设备的函数；

并且除所述第一执行过程之外，基于所述映射的第二特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供所述模块的2个逻辑实例，使得该模块的2个实例基于不同函数映射对象被执行。

13.如权利要求12所述的方法，其中2个执行过程在不同执行或特定于设备的环境中执行。

14.如权利要求12或13所述的方法，还包括接收包括另一所述模块的标识符的第二绑定消息的加载的软件模块的第二实例，第一模块的第二实例被设置成与由所述第二绑定消息标识的其它模块交换协议消息。

15.如权利要求14所述的方法，其中该模块具有用于处理所述协议消息的、针对每个所述实例的不同配置选项，并且其中每个所述绑定消息包括用于确定在所述相应模块实例的执行中实现哪些配置选项的标识符。

16.如权利要求1到15中任意一个所述的方法，其中所述或每个所述模块在单独执行过程中执行。

17.如权利要求14，15或16所述的方法，其中每个所述执行过程是线程。

18.如权利要求2所述的方法，其中所述协议消息的交换是由来自模块执行的过程中的单独执行过程来进行。

19.如权利要求18所述的方法，其中所述消息被投送到存储器的永久消息队列中，并且从该队列中取出。

20.如权利要求1到19中任意一个所述的方法，还包括：

加载中间函数映射对象到存储器中，该对象在第一函数映射对象中包括对应于通用函数和一或多个特定于设备的函数的中间函数指针，以便在第一函数映射对象中把所述通用函数映射到一或多个中间函数指针，并且还映射到一或多个特定于设备的函数。

21.如权利要求1到20中任意一个所述的方法，其中所述协议是通信协议堆栈，并且最好是无线通信协议堆栈。

22.一种提供用于在处理设备中处理信号的动态可重构协议堆栈的方法，该处理设备具有处理器和存储器，该协议由多个协议层定义；该协议堆栈包括：

若干软件模块，被载入到存储器中，每个模块被设置成基于对应于所述层之一的一组通用函数接收和处理所述信号，该模块在相应函数映射对象中包括对应于所述通用函数的通用函数指针；

若干函数映射对象，被载入存储器中，所述对象包括对应于通用函数的特定于设备的函数指针，以便把所述通用函数映射到相应模块中的一或多个特定于设备的函数；

基于所映射的特定于设备的函数执行所述模块，以便基于所述相应协议层处理所接收信号；该方法包括：

每个模块接收包括另一所述模块的标识符的绑定消息，该接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

23.如权利要求22所述的方法，还包括：

加载升级软件模块到存储器中，该模块被设置成基于对应于所述层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于所述通用函数的通用函数指针；

加载所述函数映射对象到存储器中，该对象包括对应于所述通用函数的特定于设备的函数指针，以便把所述通用函数映射到一或多个特定于设备的函数；

基于所映射的特定于设备的函数执行模块，以便基于该协议层处理所接收信号；

所述模块接收包括另一所述模块的标识符的绑定消息，所述接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

24.一种用于基于协议处理信号的方法，该协议由多个协议层定义；该方法包括：

基于对应于所述层之一的一组通用函数接收和处理所述信号；

把通用函数映射到特定于设备的函数；

执行所映射的特定于设备的函数以便基于所述协议层处理所接收信号。

25.如权利要求24所述的方法，还包括：

基于对应于其它所述层的一组通用函数接收和处理所述信号；

把通用函数映射到特定于设备的函数；

执行所映射的特定于设备的函数以便基于所述其它协议层处理该接收信号。

26.如权利要求25所述的方法，其中所述接收和处理被设置成使得所述通用函数的顺序对应于协议堆栈。

27.如权利要求26所述的方法，还包括接收绑定消息以便确定处理所述信号所依据的所述通用函数的顺序。

28.如权利要求24到27中任意一个所述的方法，其中基于每个层的通用函数的所述接收和处理通过执行软件模块来实现。

29.如权利要求24到28中任意一个所述的方法，还包括把通用函数映射到中间函数，接着映射该中间函数到所述特定于设备的函数。

30.一种提供用于处理信号的通信协议的设备，该设备具有处理器和存储器，该协议由多个协议层定义；该设备包括：

用于加载软件模块到存储器中的装置，该模块被设置成基于对应于所述层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于所述通用函数的通用函数指针；

用于加载函数映射对象到存储器中的装置，该对象包括对应于所述通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；

用于基于所映射的特定于设备的函数执行该模块以便基于所述协议层处理所接收信号的装置。

31.如权利要求30所述的设备，其中该模块被设置成与其它模块交换对应于所述信号的协议消息，所述其它模块被设置成基于对应于其它所述层的一组通用函数处理所述信号。

32.如权利要求31所述的设备，还包括：

用于加载其它软件模块到存储器中的装置，所述其它模块在函数映射对象中包括对应于所述通用函数的通用函数指针；

用于针对每个其它模块加载所述函数映射对象到存储器中的装置，该对象包括对应于所述通用函数的特定于设备的函数指针，以便把所述通用函数映射到一或多个特定于设备的函数；

用于基于所映射的特定于设备的函数执行所述其它模块，以便基于所述协议层处理所接收信号的装置。

33.如权利要求31或32所述的设备，还包括用于向所述或每个加载的软件模块发送包括另一所述模块的标识符的绑定消息的装置，第一模块被设置成与由所述绑定消息标识的其它模块交换协议消息。

34.如权利要求31到33中任意一个所述的设备，其中该模块具有用于处理所述协议消息的不同配置选项。

35.如权利要求34所述的设备，其中所述绑定消息包括用于确定在所述模块的执行中实现哪些所述配置选项的标识符。

36.如权利要求30到35中任意一个所述的设备，其中协议消息，绑定消息和通用函数指针具有公共通用格式。

37.如权利要求30到36中任意一个所述的设备，还包括：

用于加载第二软件模块到存储器中的装置，该第二模块被设置成基于对应于所述层中的第二层的一组通用函数接收和处理信号，该第二模块在第二函数映射对象中包括对应于所述通用函数的通用函数指针；

用于加载第二函数映射对象到存储器中的装置，该对象包括对应于所述通用函数的第二特定于设备的函数指针，以便把该通用函数映射到一或多个第二特定于设备的函数；

用于基于所映射的第二特定于设备的函数执行该第二模块，以便基于所述协议层处理所接收信号的装置；使得所述第一和第二模块在不同执行或特定于设备的环境中被执行。

38.如权利要求30到37中任意一个所述的设备，其中所述模块是语言无关的。

39.如权利要求38所述的设备，还包括用于将基于对应于所述层的所述一组通用函数来处理信号的高级软件语言代码编译成所述语言无关软件模块的装置。

40.如权利要求30到39中任意一个所述的设备，还包括用于基于所述映射的特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供该模块的2个逻辑实例的装置。

41.如前述权利要求中任意一个所述的设备，还包括：

用于加载第二函数映射对象到存储器中的装置，该对象包括对应于所述通用函数的第二特定于设备的函数指针，以便把该通用函数映射到一或多个第二特定于设备的函数；

以及除所述第一执行装置之外，用于基于所述映射的第二特定于设备的函数在第二执行过程中执行模块，以便基于所述协议层处理所接收信号并且以便提供所述模块的2个逻辑实例，使得该模块的2个实例基于不同函数映射对象被执行的装置。

42.如权利要求41所述的设备，其中2个执行过程在不同执行或特定于设备的环境中执行。

43.如权利要求41或42所述的设备，还包括接收包括另一所述模块的标识符的第二绑定消息的所加载软件模块的第二实例，第一模块的第二实例被设置成与由第二绑定消息标识的其它模块交换协议消息。

44.如权利要求43所述的设备，其中该模块具有用于处理所述协议消息、针对每个所述实例的不同配置选项，并且其中每个所述绑定消息包括用于确定在所述相应模块实例的执行中实现哪些所述配置选项的标识符。

45.如权利要求30到44中任意一个所述的设备，其中所述或每个模块在一个单独执行过程中被执行。

46.如权利要求43，44或45所述的设备，其中每个所述执行装置包括线程。

47.如权利要求30到46中任意一个所述的设备，还包括：

用于加载中间函数映射对象到存储器中的装置，该对象在第一函数映射对象中包括对应于通用函数和一或多个特定于设备的函数的中间函数指针，以便在第一函数映射对象中把所述通用函数映射到一或多个中间函数指针，并且还映射到一或多个特定于设备的函数。

48.如权利要求30到47中任意一个所述的设备，其中该设备是通信终端，基站或网络设备。

49.一种提供用于在处理设备中处理信号的动态可重构协议堆栈的设备，该处理设备具有处理器和存储器，该协议由多个协议层定义；该设备包括：

若干软件模块，被载入到存储器中，每个模块被设置成基于对应于所述层之一的一组通用函数接收和处理信号，该模块在相应函数映射对象中包括对应于所述通用函数的通用函数指针；

若干函数映射对象，被载入存储器中，该对象包括对应于所述通用函数的特定于设备的函数指针，以便把该通用函数映射到相应模块中的一或多个特定于设备的函数；

用于基于所映射的特定于设备的函数执行该模块，以便基于所述相应协议层处理所接收信号的装置。

50.如权利要求49所述的设备，还包括用于向每个模块发送包括另一所述模块的标识符的绑定消息的装置，所述接收模块被设置成与由所述相应绑定消息标识的其它模块交换协议消息。

51.如权利要求50所述的设备，还包括：

用于加载升级软件模块到存储器中的装置，该模块被设置成基于对应于所述层之一的一组通用函数接收和处理信号，该模块在函数映射对象中包括对应于该通用函数的通用函数指针；

用于加载所述函数映射对象到存储器中的装置，该对象包括对应于所述通用函数的特定于设备的函数指针，以便把该通用函数映射到一或多个特定于设备的函数；

用于基于所映射的特定于设备的函数执行该模块，以便基于所述协议层处理所接收信号的装置；

所述模块接收包括另一所述模块的标识符的绑定消息，所述接收模块被设置成与由相应绑定消息标识的其它模块交换协议消息。

52.一种用于基于协议处理信号的设备，该协议由多个协议层定义；该设备包括：

用于基于对应于所述层之一的一组通用函数接收和处理所述信号的装置；

用于映射所述通用函数到特定于设备的函数的装置；

用于执行所映射的特定于设备的函数，以便基于所述协议层处理所接收信号的装置。

53.如权利要求52所述的设备，还被设置成基于对应于所述层的其它层的一组通用函数处理该信号；

用于映射通用函数到特定于设备的函数的装置；

用于执行所映射的特定于设备的函数，以便基于所述其它协议层处理所接收信号的装置。

54.如权利要求53所述的设备，其中所述接收和处理被设置成使得所述通用函数的顺序对应于所述协议堆栈。

55.如权利要求54所述的设备，还包括用于接收绑定消息以便确定处理所述信号所依据的通用函数的顺序的装置。

56.如权利要求52到55中任意一个所述的设备，其中基于每个层的通用函数的所述接收和处理通过执行软件模块来实现。

57.如权利要求52到56中任意一个所述的设备，还包括用于把通用函数映射到中间函数，接着映射该中间函数到所述特定于设备的函数的装置。

58.一种程序，用于控制处理设备执行如权利要求1到29中任意一个所述的方法。

59.一种可配置设备，其根据权利要求30到57中的任意一个来进行配置。

60.一种携带处理器控制代码的承载介质，所述代码用于实现如权利要求1到57中任意一个所述的方法或设备。

Images