7.1 Wireshark插件MATE介紹

MATE是Wireshark插件，允許用戶指定不同框架之間的關聯方式。為此，MATE從幀的樹中提取數據，然后使用該信息嘗試根據MATE的配置方式對幀進行分組。PDU關聯后，MATE將使用用戶可以過濾的字段創建一個”protocol” 樹。這些字段對于所有相關幀幾乎都是相同的，因此可以根據出現在某個相關幀中的屬性來過濾一個跨越多個包含更多協議的幀的完整會話。除此之外，MATE還允許根據響應時間，組中PDU的數量等對幀進行過濾。

到目前為止，MATE已用于：

• 使用僅知道呼叫號碼的各種協議過濾呼叫的所有數據包。（MATE的最初目標）
• 根據其 “segments”之一的釋放原因，使用各種協議過濾所有呼叫的所有包。
• 從非常 “dense”的捕獲推斷出緩慢的事務。（發現請求超時）
• 查找未完成的交易（無響應）
• 通過更多網關/代理關注請求。
• 更多…

7.1.1 入門

這些是試用MATE的步驟：

• 運行Wireshark并檢查插件安裝是否正確（MATE應該出現在Help→About→Plugins中）
• 獲取一個配置文件，例如tcp.mate，并將其放置在硬盤上的某個位置。
• 轉到Preferences→Protocols→MATE，然后將配置文件名設置為要使用的文件（不必重新啟動Wireshark）
• 加載相應的捕獲文件（例如 http.cap），然后查看MATE是否添加了一些新的顯示過濾器字段，例如：mate tcp_pdu:1→tcp_ses:1 或在提示符處：path_to/wireshark -o "mate.config: tcp.mate" -r http.cap。

如果操作正確，數據包詳細信息可能如下所示：

7.1.2 MATE手冊

7.1.2.1 介紹

MATE基于包含在幀中的信息創建可過濾樹，這些幀與從其他幀獲得的信息共享某種關系。在配置文件中描述了建立這種關系的方式。配置文件告訴MATE是什么使一個PDU以及如何將其與其他PDU關聯的。

MATE分析每個幀，以從該幀的 “protocol” 樹中提取相關信息。提取的信息包含在MATE PDU中。這些包含從樹中獲取的相關屬性的列表。從現在開始，我將使用術語“ PDU”來指代MATE創建的對象，其中包含從幀中提取的相關信息。我將使用”frame” 來指代預先分析框架的各種解剖器提取的 “raw” 信息。

對于每個PDU，MATE都會檢查它是否屬于現有的“ PDU組”（Gop）。如果是，它將PDU分配給該Gop，并將所有新的相關屬性移到Gop的屬性列表中。PDU如何以及何時屬于Gops也在配置文件中進行了描述。

每次為Gop分配新的PDU時，MATE都會檢查其是否符合條件，以使其屬于 “Group of PDUs” (Gop)。當然，使Gop屬于Gog的條件也從配置文件中獲取。

一旦MATE完成了對幀的分析，它將能夠基于PDU，它們所屬的Gops以及自然而然的所有Gog為每個幀創建一個”protocol” 樹。

MATE中的信息包含在屬性/值對（AVP）中。AVP由兩個字符串組成：名稱和值。AVP用于配置中，并且那里也有操作員。使用這些運算符可以通過多種方式使AVP相互匹配。

AVP分為AVP列表（AVPL）。PDU，Gops和Gogs都有一個AVPL。它們的AVPL將以各種方式與來自配置文件的其他AVPL進行匹配。

將指示MATE如何從幀中提取AVP，以便使用AVPL創建PDU。還將指示如何使該AVPL與其他類似PDU的AVPL匹配，以使其相互關聯。在MATE中，PDU之間的關系是Gop，也具有AVPL。MATE將與其他AVPL配置為對照Gop的AVPL進行操作，以將Gops關聯到Gog。

充分了解AVP和AVPL的工作方式是了解MATE運作方式的基礎。

7.1.2.2 Attribute Value Pairs

MATE用于關聯不同幀的信息包含在屬性/值對（AVP）中。AVP由兩個字符串組成-名稱和值。在配置中使用AVP時，也會定義一個運算符。使用這些運算符可以通過多種方式使AVP相互匹配。

avp_name=”avp’s value”
another_name= “1234 is the value”

名稱是一個字符串，用于引用AVP的”kind”。除非兩個AVP的名稱相同，否則它們將不匹配。

您不應用uppercase characters在名稱或以“.”、 ”_”開頭。Capitalized名稱保留用于配置參數（我們將其稱為關鍵字）；沒有什么可以阻止您將大寫字符串用于其他用途，但這可能會造成混淆。除了本文檔，參考手冊，示例和基礎庫中的關鍵字外，我將避免使用大寫單詞。以“.”開頭的名稱 也會非常混亂，因為在舊語法中，AVPL轉換使用以“.”開頭的名稱。表示它們屬于替代AVPL。

該值是一個字符串，可以在配置中（對于配置AVP）設置，也可以由Wireshark設置，同時從框架的樹中提取有趣的字段。從字段中提取的值使用與過濾字符串相同的表示形式，只是不使用引號。

該名稱只能包含字母數字字符“ _”和“.”。名稱以運算符結尾。

該值即使是數字也將作為字符串處理。如果值中有空格，則該值必須在引號“”之間。

ip_addr=10.10.10.11,
tcp_port=1234,
binary_data=01：23：45：67：89：ab：cd：ef,
parameter12=0x23aa,
parameter_with_spaces=”this value has spaces”

運營商描述了兩個同名AVPs可能匹配的方式。請記住，除非兩個AVP的名稱相同，否則它們將不匹配。在MATE中，始終在從幀提取的AVP（稱為數據AVP）和配置的AVP之間進行匹配操作。

當前定義的MATE的AVP匹配運算符為：

• Equal = 給定的字符串與數據AVP的值字符串完全匹配

• Not Equal ! 僅在給定的值字符串不等于數據AVP的值字符串時匹配

• One Of {} 匹配其中列出的可能的字符串之一是等于數據AVP的字符串值

• Starts With ^ 匹配字符串是否給出匹配的數據AVP的值字符串的第一個字符

• Ends With $ 給定的字符串與數據AVP的值字符串的最后一個字符匹配

• Contains ~ 給定的字符串與數據AVP的值字符串的任何子字符串匹配

• Lower Than *<* 數據AVP的值字符串在語義上低于給定的字符串

• Higher Than > 數據AVP的值字符串在語義上高于給定的字符串

• Exists ? ( ? 可以省略) 匹配給定名稱的數據AVP

7.1.2.3 AVP列表

AVPL是可以與其他AVPL匹配的一組不同的AVP。每個PDU，Gop和Gog都有一個AVPL，其中包含有關它的信息。MATE用于將Pdus和Gops分組的規則是AVPL操作。

在給定的AVPL中，永遠不會有兩個完全相同的AVP。但是，只要AVPL的值不同，就可以在同一個AVPL中擁有多個同名的AVP。

一些AVPL示例：

( addr=10.20.30.40, addr=192.168.0.1, tcp_port=21, tcp_port=32534, user_cmd=PORT, data_port=12344, data_addr=192.168.0.1 )
( addr=10.20.30.40, addr=192.168.0.1, channel_id=22:23, message_type=Setup, calling_number=1244556673 )
( addr=10.20.30.40, addr=192.168.0.1, ses_id=01：23：45：67：89：ab：cd：ef )
( user_id=pippo, calling_number=1244556673, assigned_ip=10.23.22.123 )

在MATE中，有兩種類型的AVPLs：

• 包含從幀中提取的信息的數據AVPLs。
• 來自配置的操作AVPLs，用于告訴MATE如何根據其數據AVPLs關聯項目。

可以通過多種方式針對操作AVPL來操作數據AVPL：

• Loose Match：如果每個AVPL的AVP至少匹配一個，則將匹配。如果匹配，它將返回一個AVPL，其中包含與操作員的AVP匹配的操作數AVPL中的所有AVP。
• “Every” Match：如果運營商AVPL的AVP均不匹配操作數AVPL中的當前AVP，即使不是所有運營商的AVP都匹配，也將匹配。如果匹配，它將返回一個AVPL，其中包含來自操作數AVPL中與操作員AVPL中的一個AVP匹配的所有AVP。
• Strict Match：僅當運營商的每個AVP的操作數AVPL中至少有一個匹配項時，才會匹配。如果匹配，它將返回一個AVPL，其中包含來自匹配操作數的AVP。
• 在AVPL之間也要執行 一個 Merge操作，其中所有在操作數AVPL中不存在但在操作數中存在的AVP都將添加到操作數AVPL中。
• 除此之外，還有 Transformations -匹配的AVPL和要合并的AVPL的組合。

7.1.2.4 MATE Analysis

MATE對框架的分析分為三個階段：

• 在第一階段，MATE嘗試從幀的協議樹中提取MATE Pdu。MATE將創建一個PDU如果MATE的配置有一個PDU聲明，其Proto包含在框架中。
• 在第二階段，如果已經從幀中提取了一個Pdu，則MATE將通過匹配Gop聲明給出的關鍵條件，嘗試將其與其他Pdu分組為一個Gop (Group of Pdus) 。如果尚無針對Pdu的關鍵條件的Gop，則MATE如果與Gop聲明中指定的Start criterium相匹配，它將嘗試為其創建新 的Gop。
• 在第三階段，如果Pdu有Gop，MATE將嘗試使用Gog聲明的Member條件給出的條件將此Gop與其他Gops分組為Gog (Group of Groups) 。

提取和匹配邏輯來自MATE的配置。MATE的配置文件由mate.config首選項聲明。默認情況下，它是一個空字符串，表示：do not configure MATE。

MATE配置文件是聲明的列表。聲明有4種類型：Transform，Pdu，Gop和Gog。

7.1.2.4.1 Mate’s PDU’s

MATE將查看每一幀的樹，以查看是否有有用數據要提取，如果有，它將創建一個或多個包含有用信息的PDU對象。

MATE分析的第一部分是”PDU extraction”。有各種”Actions”用于指示MATE必須從當前幀的樹提取到MATE的PDU中的內容。

7.1.2.4.1.1 PDU data extraction

MATE將為幀中存在的Proto類型的每個不同Proto字段創建一個Pdu。MATE將從該字段的樹中提取在7.1.7.1 Pdsu 的配置操作聲明中定義的那些字段，它們在框架中的初始偏移位于當前Proto以及給定的Transport和Payload語句的邊界之內。

Pdu dns_pdu Proto dns Transport ip {
    Extract addr From ip.addr;
    Extract dns_id From dns.id;
    Extract dns_resp From dns.flags.response;
};

MATE將為幀中存在的Proto類型的每個不同Proto字段創建一個Pdu。MATE將從字段樹中獲取在7.1.7.1 Pdsu 的配置操作AVPL 中定義的那些字段，它們在幀中的初始偏移位于當前Proto和各種已分配傳輸的邊界之內。

一旦MATE找到了要從框架創建Pdu 的Proto字段，它將在框架中向后移動以查找相應的*Transport *字段。之后，它將為每個聲明為其值的字段實例創建一個名為AVP的名稱，該名稱在AVPL其余部分中給出。

有時我們需要來自多個Transport protocol的信息。在這種情況下，MATE將向后檢查幀，以查找給定堆棧中的各種 Transport protocol。MATE將僅根據框架中的”protocol”選擇最接近的傳輸邊界。

這樣，我們將使框架中出現的每個Proto所有Pdu 與其相對傳輸都匹配。

Pdu isup_pdu Proto isup Transport mtp3/ip {
        Extract m3pc From mtp3.dpc;
        Extract m3pc From mtp3.opc;
        Extract cic From isup.cic;
        Extract addr From ip.addr;
        Extract isup_msg From isup.message_type;
};

這樣可以為Pdu 分配正確的Transport，避免重復的傳輸協議條目（例如，在基于IP的隧道ip情況下）。

Pdu ftp_pdu Proto ftp Transport tcp/ip {
        Extract addr From ip.addr;
        Extract port From tcp.port;
        Extract ftp_cmd From ftp.command;
};

除了必需的Transport之外，還有一個可選的Payload 語句，該語句與Transport **差不多，但是引用Proto范圍之后的元素。在有效載荷協議可能未出現在Pdu中但Pdu屬于同一類別的情況下，它很有用。

Pdu mmse_over_http_pdu Proto http Transport tcp/ip {
        Payload mmse;
        Extract addr From ip.addr;
        Extract port From tcp.port;
        Extract method From http.request.method;
        Extract content From http.content_type;
        Extract http_rq From http.request;
        Extract resp From http.response.code;
        Extract host From http.host;
        Extract trx From mmse.transaction_id;
        Extract msg_type From mmse.message_type;
        Extract notify_status From mmse.status;
        Extract send_status From mmse.response_status;
};

7.1.2.4.1.2 創建PDU的條件

在某些情況下，除非某些提取的屬性滿足或不滿足某些條件，否則我們不希望MATE創建PDU。為此，我們使用Pdu聲明的 Criteria語句。

Pdu isup_pdu Proto isup Transport mtp3/ip {
    ...

   // MATE will create isup_pdu PDUs only when there is not a point code '1234'
   Criteria Reject Strict (m3pc=1234);
};

Pdu ftp_pdu Proto ftp Transport tcp/ip {
    ...

    // MATE will create ftp_pdu PDUs only when they go to port 21 of our ftp_server
    Criteria Accept Strict (addr=10.10.10.10, port=21);
};

該Criteria語句給出一個動作（Accept or Reject），匹配模式（Strict, Loose or Every）和AVPL針對其匹配當前所提取的一個。

7.1.2.4.1.3 轉換PDU的屬性

一旦將字段提取到Pdu的AVPL中，MATE將對其應用任何聲明的轉換。轉換的應用方式及其工作方式將在后面介紹。但是，很有必要知道，一旦為Pdu創建了AVPL，就可以在分析之前對其進行轉換。這樣我們就可以整理數據以簡化分析。

7.1.2.4.1.4 MATE的PDU樹

每個成功創建的Pdu都會在幀解剖中添加一個MATE樹。如果Pdu與任何Gop不相關，則Pdu的樹將僅包含Pdu的信息，如果將其分配給Gop，則樹也將包含Gop項，并且對于Gog級別也是如此。

mate dns_pdu:1
    dns_pdu: 1
        dns_pdu time: 3.750000
        dns_pdu Attributes
            dns_resp: 0
            dns_id: 36012
            addr: 10.194.4.11
            addr: 10.194.24.35

Pdu的樹包含一些可過濾的字段

• mate.dns_pdu將包含“ dns_pdu” Pdu的編號
• mate.dns_pdu.RelativeTime將包含自開始捕獲以來經過的時間（以秒為單位）
• 樹也將包含Pdu的各種屬性，它們都是字符串（在過濾器中用作“ 10.0.0.1”，而不是10.0.0.1）
  • mate.dns_pdu.dns_resp
  • mate.dns_pdu.dns_id
  • mate.dns_pdu.addr

7.1.2.4.2 Grouping Pdus together (Gop)

一旦MATE創建了Pdu，它將進入Pdu分析階段。在PDU分析階段，MATE將嘗試將相同類型的Pdu分組為 ‘Groups of Pdus’ (aka Gops) ，并將一些AVP從Pdu’s AVPL 復制到 Gop’s AVPL。

7.1.2.4.2.1 What can belong to a Gop

給定一個Pdu，MATE要做的第一件事是檢查配置中是否存在給定Pdu類型的Gop聲明。如果是這樣，它將使用其 Match AVPL與Pdu’s AVPL進行匹配；如果它們不匹配，則分析階段完成。如果存在匹配項，則AVPL是Gop的候選密鑰，它將用于在Gop的索引中搜索要分配當前PDU的Gop。如果沒有這樣的Gop，并且此Pdu 與Pdu類型的Gop聲明的*Start *條件不匹配 ，則Pdu將保持未分配狀態，僅完成分析階段。

Gop ftp_ses On ftp_pdu Match (addr, addr, port, port);
Gop dns_req On dns_pdu Match (addr, addr, dns_id);
Gop isup_leg On isup_pdu Match (m3pc, m3pc, cic);

7.1.2.4.2.2 Start of a Gop

如果存在匹配項，則候選密鑰將用于搜索Gop的索引，以查看是否已經存在以相同方式匹配Gop的密鑰的Gop。如果Gops集合中存在這樣的匹配項，并且PDU與 該類型的Start AVPL 不匹配，則PDU將分配給匹配的Gop。如果是 Start匹配，MATE將檢查Gop是否已經停止。如果Gop已停止，則會創建一個新的Gop，并將替換Gop索引中的舊Gop。

Gop ftp_ses On ftp_pdu Match (addr, addr, port, port) {
    Start (ftp_cmd=USER);
};

Gop dns_req On dns_pdu Match (addr, addr, dns_id) {
    Start (dns_resp=0);
};

Gop isup_leg On isup_pdu Match (m3pc, m3pc, cic) {
    Start (isup_msg=1);
};

如果沒有為Gop提供Start，則其AVPL與現有Gog的密鑰匹配的Pdu將充當Gop的開始。

7.1.2.4.2.3 What goes into the Gop’s AVPL

一旦我們知道Gop存在并將Pdu分配給它，MATE會將與密鑰匹配的所有屬性以及與Extra AVPL 匹配的Pdu’s AVPL的所有AVP復制到Gop’s AVPL中。

Gop ftp_ses On ftp_pdu Match (addr, addr, port, port) {
    Start (ftp_cmd=USER);
    Extra (pasv_prt, pasv_addr);
};

Gop isup_leg On isup_pdu Match (m3pc, m3pc, cic) {
    Start (isup_msg=1);
    Extra (calling, called);
};

7.1.2.4.2.4 Gop結束

將Pdu分配給Gop之后，MATE將檢查Pdu是否與Stop匹配，如果匹配，MATE會將Gop標記為已停止。即使在停止之后，也可能會為Gop分配與其密鑰匹配的新Pdu，除非該Pdu與Start匹配。如果是這樣，則MATE將從該Pdu開始創建一個新的Gop。

Gop ftp_ses On ftp_pdu Match (addr, addr, port, port) {
    Start (ftp_cmd=USER);
    Stop (ftp_cmd=QUIT); // The response to the QUIT command will be assigned to the same Gop
    Extra (pasv_prt, pasv_addr);
};

Gop dns_req On dns_pdu Match (addr, addr, dns_id) {
    Start (dns_resp=0);
    Stop (dns_resp=1);
};

Gop isup_leg On isup_pdu Match (m3pc, m3pc, cic) {
    Start (isup_msg=1); // IAM
    Stop (isup_msg=16); // RLC
    Extra (calling, called);
};

如果沒有為給定的Gop指定Stop *標準，則Gop將在創建后立即停止。但是，與其他任何Gop一樣，匹配Gop密鑰的Pdu仍將分配給Gop，除非它們與Start*條件匹配，在這種情況下，將創建使用相同密鑰的新Gop。

7.1.2.4.3 Gop’s tree

對于每個包含屬于Gop的Pdu的幀，MATE將為該Gop創建一棵樹。

下面的示例表示由dns_pdu和dns_req 示例創建的樹。

...
mate dns_pdu:6->dns_req:1
    dns_pdu: 6
        dns_pdu time: 2.103063
        dns_pdu time since begining of Gop: 2.103063
        dns_req: 1
            dns_req Attributes
                dns_id: 36012
                addr: 10.194.4.11
                addr: 10.194.24.35
            dns_req Times
                dns_req start time: 0.000000
                dns_req hold time: 2.103063
                dns_req duration: 2.103063
            dns_req number of PDUs: 2
                Start PDU: in frame 1
                Stop PDU: in frame 6 (2.103063 : 2.103063)
        dns_pdu Attributes
            dns_resp: 1
            dns_id: 36012
            addr: 10.194.4.11
            addr: 10.194.24.35

除了 pdu’s tree之外，此tree還包含有關屬于Gop的Pdu之間的關系的信息。這樣我們就可以：

• mate.dns_req，其中包含此dns_req Gop的ID。這將出現在屬于dns_req Gops的幀中。

• mate.dns_req.dns_id和mate.dns_req.addr，它們代表復制到Gop中的屬性的值。

• Gop的計時器

  • mate.dns_req.StartTime從開始捕獲到Gop開始經過的時間（以秒為單位）。
  • mate.dns_req。在分配給該Gop的開始Pdu和停止Pdu之間經過的時間（僅在已為Gop聲明了停止條件并且已到達匹配的Pdu時創建）。
  • mate.dns_req.Duration在開始的Pdu和分配給此Gop的最后一個Pdu之間經過的時間。

• mate.dns_req.NumOfPdus屬于此Gop的Pdus的數量

  • 此Gop的pdu的幀數的可過濾列表

7.1.2.4.3.1 Gop’s timers

請注意，Gop有兩個”timers”：

• Time，僅為已停止的Gops定義，并提供在Start和Stop Pdus之間經過的時間。
• Duration，針對其狀態的每個Gop事項定義，并給出在其Start Pdu和分配給該Gop的最后一個Pdu之間經過的時間。

所以：

• 我們可以過濾已被mate.xxx.Time停止的 Gops的Pdus
• 我們可以使用mate.xxx && mate.xxx.Time篩選屬于不間斷Gops的Pdus
• 我們可以使用mate.xxx.Duration篩選屬于停止的Gops的Pdus
• 我們可以篩選出與Gops關聯的Pdus，它們花費了更多（或更短的時間）來完成mate.xxx.Time> 0.5（0.5秒以上）（您也可以嘗試將它們用作彩色濾光片，以了解響應時間何時開始增長）

7.1.2.4.4 Grouping Gops together (Gog)

創建Gops或更改其AVPL時，將對Gops進行（重新）分析，以檢查它們是否匹配現有的組群組（Gog）或可以創建一個新的群組。Gop分析分為兩個階段。在第一階段，檢查仍未分配的Gop，以驗證它是否屬于現有Gog或可以創建一個新Gog。第二階段最終檢查Gog，并將其密鑰注冊到Gogs索引中。

作者有多種理由認為需要重新實現此功能，因此在不久的將來，此方法的實現方式可能會發生深刻的變化。文檔的此部分反映了Wireshark 0.10.9起的MATE版本。在將來的版本中，這將發生變化。

7.1.2.4.4.1 Declaring a Group Of Groups

我們必須配置Gog的第一件事就是告訴MATE它已經存在。

Gog web_use {
   ...
};

7.1.2.4.4.2 Telling MATE what could be a Gog member

然后，我們必須告訴MATE在候選Gops中尋找匹配項的內容。

Gog web_use {
    Member http_ses (host);
    Member dns_req (host);
};

7.1.2.4.4.3 Getting interesting data into the Gop

通常，除用于匹配的屬性外，其他屬性也會很有趣。為了從Gop復制到Gog其他有趣的屬性，我們可以像對Gops一樣使用Extra。

Gog web_use {
    ...
    Extra (cookie);
};

7.1.2.4.4.4 Gog’s tree

mate http_pdu:4->http_req:2->http_use:1
    http_pdu: 4
        http_pdu time: 1.309847
        http_pdu time since begining of Gop: 0.218930
        http_req: 2
            ... (the gop's tree for http_req: 2) ..
        http_use: 1
            http_use Attributes
                host: www.example.com
            http_use Times
                http_use start time: 0.000000
                http_use duration: 1.309847
            number of GOPs: 3
                dns_req: 1
                    ... (the gop's tree for dns_req: 1) ..
                http_req: 1
                    ... (the gop's tree for http_req: 1) ..
                http_req of current frame: 2

我們可以過濾：

• mate.http_use.Duration在Gog的第一幀和分配給它的最后一個幀之間經過的時間。

• 傳遞給Gog的屬性

  • mate.http_use.host

7.1.2.4.5 AVPL轉換

轉換是一系列匹配規則，可以選擇通過附加的AVPL修改匹配結果來完成。此類修改可以是插入（合并）或替換。可以在對象的AVPL進行進一步處理之前將其用作輔助工具。它們在某些情況下非常有用。

7.1.2.4.5.1 Syntax

AVPL轉換以以下方式聲明：

  Transform name {
   Match [Strict|Every|Loose] match_avpl [Insert|Replace] modify_avpl ;
   ...
 };

該name是AVPL轉換的句柄。以后調用它時，它用于引用該變換。

可選的匹配模式限定符（Strict，Every或Loose）用于選擇匹配模式，如上所述。Strict是默認值，可以省略。

可選的修改模式限定符指示MATE應該如何使用修改的AVPL：

• 默認值Insert（其可被省略）使modify_avpl 被merged到現有的數據AVPL，
• 所述Replace導致從數據AVPL所有匹配的AVP被 replaced由modify_avpl。

所述modify_avpl可以是空的一個; 在某些情況下，這對于Insert和Replace修改模式很有用。

例子：

  Transform insert_name_and {
   Match Strict (host=10.10.10.10, port=2345) Insert (name=JohnDoe);
};
adds name=JohnDoe to the data AVPL if it contains host=10.10.10.10 and port=2345

Transform insert_name_or {
   Match Loose (host=10.10.10.10, port=2345) Insert (name=JohnDoe);
};
adds name=JohnDoe to the data AVPL if it contains host=10.10.10.10 or port=2345

Transform replace_ip_address {
   Match (host=10.10.10.10) Replace (host=192.168.10.10);
};
replaces the original host=10.10.10.10 by host=192.168.10.10

Transform add_ip_address {
   Match (host=10.10.10.10) (host=192.168.10.10);
};
adds (inserts) host=192.168.10.10 to the AVPL, keeping the original host=10.10.10.10 in it too

 Transform replace_may_be_surprising {
   Match Loose (a=aaaa, b=bbbb) Replace (c=cccc, d=dddd);
 };

結果：

• (a=aaaa, b=eeee) gets transformed to (b=eeee, c=cccc, d=dddd) because a=aaaa did match so it got replaced while b=eeee did not match so it has been left intact,
• (a=aaaa, b=bbbb) gets transformed to (c=cccc, d=dddd) because both a=aaaa and b=bbbb did match.

7.1.2.4.5.2 Usage

將轉換添加到PDU，Gop或Gogs的聲明中，通過在聲明中添加Transform name_list語句來完成的：

Pdu my_proto_pdu Proto my_proto Transport ip {
    Extract addr From ip.addr;
    ...
    Transform my_pdu_transform[, other_pdu_transform[, yet_another_pdu_transform]];
};

• 如果是PDU，則在創建PDU后將對其進行轉換。
• 對于Gop和Gog，在創建轉換時以及每次更改時，都會將轉換列表應用于其各自的AVPL。

7.1.2.4.6 Operation

• 可以使用Transform語句為每個項（Pdu，Gop或Gog）提供一個預先聲明的Transforms列表。
• 每次項目的AVPL更改時，都會針對該項目提供的列表上的所有 “Transforms”對其進行操作。列表上的Transforms從左到右應用。
• 在每個Transforms中，將從最頂層開始的對Transform的Match子句操作該項的AVPL，直到嘗試了所有子句或其中一個成功為止。

MATE的Transforms可用于許多不同的事物，例如：

7.1.2.4.6.1 Multiple Start/Stop conditions for a Gop

使用Transforms，我們可以向Gop添加多個開始或停止條件。

Transform start_cond {
  Match (attr1=aaa,attr2=bbb) (msg_type=start);
  Match (attr3=www,attr2=bbb) (msg_type=start);
  Match (attr5^a) (msg_type=stop);
  Match (attr6$z) (msg_type=stop);
};

Pdu pdu ... {
  ...
  Transform start_cond;
}

Gop gop ... {
  Start (msg_type=start);
  Stop (msg_type=stop);
  ...
}

7.1.2.4.6.2 Marking Gops and Gogs to filter them easily

Transform marks {
  Match (addr=10.10.10.10, user=john) (john_at_host);
  Match (addr=10.10.10.10, user=tom) (tom_at_host);
}

...

Gop my_gop ... {
  ...
  Transform marks;
}

之后，我們可以使用顯示過濾器mate.gop.john_at_host或 mate.gop.tom_at_host

7.1.2.4.6.3 Adding direction knowledge to MATE

Transform direction_as_text {
  Match (src=192.168.0.2, dst=192.168.0.3) Replace (direction=from_2_to_3);
  Match (src=192.168.0.3, dst=192.168.0.2) Replace (direction=from_3_to_2);
};

Pdu my_pdu Proto my_proto Transport tcp/ip {
  Extract src From ip.src;
  Extract dst From ip.dst;
  Extract addr From ip.addr;
  Extract port From tcp.port;
  Extract start From tcp.flags.syn;
  Extract stop From tcp.flags.fin;
  Extract stop From tcp.flags.rst;
  Transform direction_as_text;
}

Gop my_gop On my_pdu Match (addr,addr,port,port) {
  ...
  Extra (direction);
}

7.1.2.4.6.4 NAT

跟蹤時NAT可能會產生問題，但是我們可以通過將NATed IP地址和路由器的以太網地址轉換為非NAT地址來輕松解決此問題：

Transform denat {
  Match (addr=192.168.0.5, ether=01:02:03:04:05:06) Replace (addr=123.45.67.89);
  Match (addr=192.168.0.6, ether=01:02:03:04:05:06) Replace (addr=123.45.67.90);
  Match (addr=192.168.0.7, ether=01:02:03:04:05:06) Replace (addr=123.45.67.91);
}

Pdu my_pdu Proto my_proto transport tcp/ip/eth {
  Extract ether From eth.addr;
  Extract addr From ip.addr;
  Extract port From tcp.port;
  Transform denat;
}

7.1.3 MATE的配置教程

我們將展示一個MATE配置，該配置首先為每個DNS和HTTP請求創建Gops，然后根據主機將Gops綁在一起。最后，我們將把來自不同用戶的不同Gogs請求分開。

加載此MATE配置后，我們可以：

• 使用mate.http_use.Duration> 5.5根據從DNS請求加載完整頁面以解析其名稱直到加載最后一張圖像所需的時間來過濾幀。
• 使用mate.http_use.client ==“ 10.10.10.20” && mate.http_use.host ==“ www.example.com” 隔離與特定用戶訪問相關的DNS和HTTP數據包。
• 使用mate.http_req.Duration> 1.5來過濾所有HTTP請求的數據包，這些數據包需要超過1.5秒的時間才能完成。

完整的配置文件在這里： web.mate

注：在這個例子中我用dns.qry.name這是自Wireshark的版本0.10.9定義。假設您已經安裝了mate插件，則可以使用當前的Wireshark版本對其進行測試。

7.1.3.1 DNS請求的Gop

首先，我們將告訴MATE如何為每個DNS請求/響應創建Gop。

MATE需要知道是什么使DNS PDU產生。我們使用Pdu聲明對此進行描述：

Pdu dns_pdu Proto dns Transport ip {
  Extract addr From ip.addr;
  Extract dns_id From dns.id;
  Extract dns_resp From dns.flags.response;
};

使用Proto dns，我們告訴MATE每次發現dns時都要創建Pdus 。使用 Transport ip，我們通知MATE我們感興趣的某些字段位于框架的ip部分。最后，我們告訴MATE將ip.addr作為 addr導入，將dns.id作為dns_id導入，并且將dns.flags.response作為dns_resp導入。

告訴MATE如何提取dns_pdus后，我們將告訴它如何匹配請求和響應并將它們分組為Gop。為此，我們將使用Gop 聲明來定義Gop，然后使用Start和Stop語句告訴它Gop的開始和結束時間。

Gop dns_req On dns_pdu Match (addr,addr,dns_id) {
  Start (dns_resp=0);
  Stop (dns_resp=1);
};

使用Gop聲明，我們告訴MATE Gop的Name是dns_req，dns_pdus可以成為Gop的成員，用于將Pdus與Gop匹配的密鑰。

該Gop的密鑰是“ addr，addr，dns_id”。這意味著，為了屬于同一Gop，dns_pdus必須具有相同的地址和 請求ID。然后，我們指示MATE 每當dns_pdu匹配“ dns_resp = 0”時dns_req **就會啟動，而當另一個dns_pdu matches“ dns_resp = 1”時它將停止。

此時，如果使用此配置打開捕獲文件，則可以使用顯示過濾器mate.dns_req.Time> 1來僅查看需要一秒鐘以上才能完成的DNS請求數據包。

我們可以使用顯示過濾器mate.dns_req &&！mate.dns_req。查找沒有給出響應的請求的時間。mate.xxx.Time僅針對已停止的Gops設置。

7.1.3.2 HTTP請求的Gop

此其他示例為每個HTTP請求創建一個Gop。

Pdu http_pdu Proto http Transport tcp/ip {
  Extract addr From ip.addr;
  Extract port From tcp.port;
  Extract http_rq From http.request.method;
  Extract http_rs From http.response;
  DiscardPduData true;
};

Gop http_req On http_pdu Match (addr, addr, port, port) {
  Start (http_rq);
  Stop (http_rs);
};

因此，如果我們使用此配置打開捕獲

• 使用mate.http_req.Time> 1過濾將給出所有請求，其中響應標頭要花費一秒鐘以上的時間
• 使用mate.http_req.Duration> 1.5過濾將顯示那些耗時超過1.5秒的請求。

您必須知道mate.xxx.Time給出了與GopStart匹配的pdu和與GopStop匹配的pdu之間的時間（以秒為單位）（是的，您可以使用此創建計時器！）。另一方面，mate.xxx.Duration為您提供了GopStart和分配給該Gop的最后一個pdu之間的時間，無論它是否是停止點。在GopStop之后，與Gop的密鑰匹配的Pdu仍將被分配給同一Gop，只要它們與GopStart不匹配，在這種情況下，將創建一個具有相同密鑰的新Gop。

7.1.3.3 Getting DNS and HTTP together into a Gog

我們將使用單個示例的Pdu和Gop定義將屬于請求和對某個主機的響應的所有http數據包以及用于解析其域名的dns請求和響應綁定到一個Gog上

為了將DNS和HTTP請求分組在一起，我們需要將這兩個協議共享的部分信息導入Pdus和Gops。一旦定義了Pdus和Gops，我們就可以使用Extract（對于Pdus）和 Extract（對于Gops）語句來告訴MATE還有什么其他協議字段要添加到Pdus和Gops的AVPL中。我們在適當的聲明中添加以下語句：

Extract host From http.host; // to Pdu http_pdu as the last Extract in the list
Extra (host); // to Gop http_req after the Stop
Extract host From dns.qry.name; // to Pdu dns_pdu as the last Extract in the list
Extra (host); // to Gop dns_req after the Stop

在這里，我們告訴MATE將http.host導入到http_pdu中，并將dns.qry.name 導入到dns_pdu中作為host。我們還必須告訴MATE將host 屬性從Pdus復制到Gops，我們使用Extra來完成。

一旦獲得了Pdus和Gops中所需的所有數據，我們就可以告訴MATE是什么使不同的Gops屬于某個Gog。

Gog http_use {
  Member http_req (host);
  Member dns_req (host);
  Expiration 0.75;
};

使用Gog聲明，我們告訴MATE定義一個名為 http_use的Gog類型，該類型的到期時間是在所有屬于它的Gops被停止之后的0.75秒。在那之后，具有相同密鑰匹配的最終新Gop將創建一個新Gog，而不是被添加到先前的Gog。

使用Member語句，我們告訴MATE *http_reqs with the same host **屬于同一Gog，對于`dns_req*s`屬于同一事物。

到目前為止，我們已經指示mate將與會話相關的每個數據包分組到某個主機。此時，如果我們打開一個捕獲文件，然后：

• 顯示過濾器mate.http_use.Duration> 5將僅顯示從DNS請求開始到http響應的最后一個數據包結束已花費5秒鐘以上的請求。
• 顯示過濾器mate.http_use.host ==“ www.w3c.org”將顯示與定向到www.w3c.org的請求有關的所有數據包（DNS和HTTP）

7.1.3.4 Separating requests from multiple users

MATE具有可用于解決此類分組問題的工具。該工具是“ Transforms”。定義后，可以將它們應用于Pdus，Gops和Gogs，并且它們可能會根據那里的內容替換或插入更多屬性。我們將使用它們來創建一個名為client的屬性，通過該屬性我們將分隔不同的請求。

對于DNS，我們只需要將請求的ip.src從DNS請求移到Gop中。

因此，我們首先告訴MATE將ip.src導入為客戶端：

Extract client From ip.src;

接下來，我們告訴MATE更換（dns_resp=1, client）dns_resp = 1的PDU。這樣，我們將屬性client僅保留在DNS請求Pdu中（即來自客戶端的數據包）。為此，我們必須在Pdu聲明之前添加一個 Transform聲明（在這種情況下，只有一個子句）。使用它：

Transform rm_client_from_dns_resp {
Match (dns_resp=1, client) Replace (dns_resp=1);
};

接下來，我們通過 在dns_pdu Pdu 的Extract列表之后添加以下行來調用轉換：

Transform rm_client_from_dns_resp;

我們必須從響應和響應的 “continuations”中都刪除帶有ip.src的屬性，但是由于沒有什么可以繼續篩選的條件，因此我們必須首先添加一個假屬性。然后，當假屬性出現時，我們必須刪除客戶端。這是可能的，因為事實是Transform 中的Match子句一個接一個地執行，直到其中一個成功為止。首先，我們聲明另外兩個Transforms：

Transform rm_client_from_http_resp1 {
  Match (http_rq); //first match wins so the request won't get the not_rq attribute inserted
  Match Every (addr) Insert (not_rq); //this line won't be evaluated if the first one matched so not_rq won't be inserted to requests
};

Transform rm_client_from_http_resp2 {
  Match (not_rq, client) Replace (); //replace "client and not_rq" with nothing (will happen only in the response and eventual parts of it)
};

接下來，我們在http_pdu聲明中添加另一個Extract語句，并以適當的順序應用上面聲明的兩個Transforms：

Extract client From ip.src;
Transform rm_client_from_http_resp1, rm_client_from_http_resp2;

在MATE中，Transform_s listed for an item will be evaluated, while inside a single _Transform，該評估將在第一個成功的Match子句處停止 。這就是為什么我們在添加not_rq屬性之前先匹配http_rq來擺脫第一個序列。然后，我們應用第二個 Transform，如果同時存在，則刪除not_rq和client。

一旦在Pdus中獲得了所有需要的東西，我們必須告訴MATE 通過將客戶端添加到兩個Gop聲明的Extra列表中，將屬性client從Pdu’s復制到相應的Gops ：

Extra (host, client);

最重要的是，我們需要將Gop鍵的舊聲明修改為包含client和host的新聲明。因此，我們 通過以下方式更改Gog Member聲明：

Member http_req (host, client);
Member dns_req (host, client);

7.1.4 MATE配置示例

以下是MATE各種配置示例的集合。其中許多都是無用的，因為 “conversations”功能做得更好。無論如何，它們旨在幫助用戶了解如何配置MATE。

7.1.4.1 TCP會話

以下示例從每個TCP會話中創建一個GoP。

Pdu tcp_pdu Proto tcp Transport ip {
    Extract addr From ip.addr;
    Extract port From tcp.port;
    Extract tcp_start From tcp.flags.syn;
    Extract tcp_stop From tcp.flags.reset;
    Extract tcp_stop From tcp.flags.fin;
};

Gop tcp_ses On tcp_pdu Match (addr, addr, port, port) {
    Start (tcp_start=1);
    Stop (tcp_stop=1);
};

Done;

在99.9％的情況下，這可能會很好，但是10.0.0.1:20→10.0.0.2:22和10.0.0.1:22→10.0.0.2:20如果它們在時間上重疊，它們都將落入同一gop中。

• 使用mate.tcp_ses.Time> 1過濾將使所有持續時間少于一秒的會話
• 使用mate.tcp_ses.NumOfPdus < 5過濾將顯示所有少于5個數據包的tcp會話。
• 使用mate.tcp_ses.Id == 3過濾將顯示MATE找到的第三個tcp會話的所有數據包

7.1.4.2 一個完整的FTP會話的Gog

此配置允許在單個Gog中綁定一個完整的被動ftp會話（包括數據傳輸）。

Pdu ftp_pdu Proto ftp Transport tcp/ip {
        Extract ftp_addr From ip.addr;
        Extract ftp_port From tcp.port;
        Extract ftp_resp From ftp.response.code;
        Extract ftp_req From ftp.request.command;
        Extract server_addr From ftp.passive.ip;
        Extract server_port From ftp.passive.port;

        LastPdu;
};

Pdu ftp_data_pdu Proto ftp-data Transport tcp/ip{
        Extract server_addr From ip.src;
        Extract server_port From tcp.srcport;

};

Gop ftp_data On ftp_data_pdu (server_addr, server_port) {
        Start (server_addr);
};

Gop ftp_ctl On ftp_pdu (ftp_addr, ftp_addr, ftp_port, ftp_port) {
        Start (ftp_resp=220);
        Stop (ftp_resp=221);
        Extra (server_addr, server_port);
};

Gog ftp_ses {
        Member ftp_ctl (ftp_addr, ftp_addr, ftp_port, ftp_port);
        Member ftp_data (server_addr, server_port);
};

Done;

注意：由于沒有什么區別，因此此配置為每個ftp數據包（而不是每次傳輸）創建一個Gop。預啟動的Gops可以避免這種情況。

7.1.4.3 使用RADIUS過濾特定用戶的SMTP流量

在許多國家/地區，不道德地監視他人是非法的。這是一個示例，旨在說明如何執行此操作，而不是邀請您這樣做。在有充分理由的情況下，應由警察來進行此類工作。

Pdu radius_pdu On radius Transport udp/ip {
    Extract addr From ip.addr;
    Extract port From udp.port;
    Extract radius_id From radius.id;
    Extract radius_code From radius.code;
    Extract user_ip From radius.framed_addr;
    Extract username From radius.username;
}

Gop radius_req On radius_pdu (radius_id, addr, addr, port, port) {
    Start (radius_code {1|4|7} );
    Stop (radius_code {2|3|5|8|9} );
    Extra (user_ip, username);
}

// we define the smtp traffic we want to filter
Pdu user_smtp Proto smtp Transport tcp/ip {
    Extract user_ip From ip.addr;
    Extract smtp_port From tcp.port;
    Extract tcp_start From tcp.flags.syn;
    Extract tcp_stop From tcp.flags.reset;
}

Gop user_smtp_ses On user_smtp (user_ip, user_ip, smtp_port!25) {
    Start (tcp_start=1);
    Stop (tcp_stop=1);
}

// with the following group of groups we'll group toghether the radius and the smtp
// we set a long expiration to avoid the session expire on long pauses.
Gog user_mail {
    Expiration 1800;
    Member radius_req (user_ip);
    Member user_smtp_ses (user_ip);
    Extra (username);
}

Done;

過濾捕獲文件與mate.user_mail.username ==“theuser”將過濾半徑包和SMTP流量“theuser”。

7.1.4.4 H323 Calls

此配置將從每個呼叫中創建一個Gog。

Pdu q931 Proto q931 Transport ip {
        Extract addr From ip.addr;
        Extract call_ref From q931.call_ref;
        Extract q931_msg From q931.message_type;
        Extract calling From q931.calling_party_number.digits;
        Extract called From q931.called_party_number.digits;
        Extract guid From h225.guid;
        Extract q931_cause From q931.cause_value;
};

Gop q931_leg On q931 Match (addr, addr, call_ref) {
        Start (q931_msg=5);
        Stop (q931_msg=90);
        Extra (calling, called, guid, q931_cuase);
};

Pdu ras Proto h225.RasMessage Transport ip {
        Extract addr From ip.addr;
        Extract ras_sn From h225.requestSeqNum;
        Extract ras_msg From h225.RasMessage;
        Extract guid From h225.guid;
};

Gop ras_req On ras Match (addr, addr, ras_sn) {
        Start (ras_msg {0|3|6|9|12|15|18|21|26|30} );
        Stop (ras_msg {1|2|4|5|7|8|10|11|13|14|16|17|19|20|22|24|27|28|29|31});
        Extra (guid);
};

Gog call {
        Member ras_req (guid);
        Member q931_leg (guid);
        Extra (called,calling,q931_cause);
};

Done;

這樣，我們可以：

• 過濾特定呼叫者的所有信令：mate.call.caller ==“ 123456789”
• 過濾具有特定釋放原因的呼叫的所有信令：mate.call.q931_cause == 31
• 過濾非常短的呼叫的所有信令：mate.q931_leg.Time < 5

7.1.4.5 MMS

在此示例中，MMS發送或接收的所有組件都將綁定到一個Gog中。請注意，此示例使用Payload子句，因為MMS傳遞通過HTTP或WSP使用MMSE。由于不可能僅通過MMSE將檢索請求與響應相關聯（該請求只是沒有任何MMSE的HTTP GET），因此Gop由HTTP Pdu組成，但是需要從主體中提取MMSE數據。

## WARNING: this example has been blindly translated from the "old" MATE syntax
## and it has been verified that Wireshark accepts it. However, it has not been
## tested against any capture file due to lack of the latter.

Transform rm_client_from_http_resp1 {
        Match (http_rq);
        Match Every (addr) Insert (not_rq);
};

Transform rm_client_from_http_resp2 {
        Match (not_rq,ue) Replace ();
};

Pdu mmse_over_http_pdu Proto http Transport tcp/ip {
        Payload mmse;
        Extract addr From ip.addr;
        Extract port From tcp.port;
        Extract http_rq From http.request;
        Extract content From http.content_type;
        Extract resp From http.response.code;
        Extract method From http.request.method;
        Extract host From http.host;
        Extract content From http.content_type;
        Extract trx From mmse.transaction_id;
        Extract msg_type From mmse.message_type;
        Extract notify_status From mmse.status;
        Extract send_status From mmse.response_status;
        Transform rm_client_from_http_resp1, rm_client_from_http_resp2;
};

Gop mmse_over_http On mmse_over_http_pdu Match (addr, addr, port, port) {
        Start (http_rq);
        Stop (http_rs);
        Extra (host, ue, resp, notify_status, send_status, trx);
};

Transform mms_start {
        Match Loose() Insert (mms_start);
};

Pdu mmse_over_wsp_pdu Proto wsp Transport ip {
        Payload mmse;
        Extract trx From mmse.transaction_id;
        Extract msg_type From mmse.message_type;
        Extract notify_status From mmse.status;
        Extract send_status From mmse.response_status;
        Transform mms_start;
};

Gop mmse_over_wsp On mmse_over_wsp_pdu Match (trx) {
        Start (mms_start);
        Stop (never);
        Extra (ue, notify_status, send_status);
};

Gog mms {
        Member mmse_over_http (trx);
        Member mmse_over_wsp (trx);
        Extra (ue, notify_status, send_status, resp, host, trx);
        Expiration 60.0;
};

7.1.5 MATE的配置庫

MATE庫包含幾種協議的GoP定義。庫協議包含在您的MATE配置中，using: Action=Include; Lib=proto_name;.

對于帶有庫條目的每個協議，我們都會從PDU中定義為該協議創建GoP所需的內容，最終包括所有條件和非常必要的GoP定義（i.e. GopDef, GopStart and GopStop）。

7.1.5.1 通用協議

7.1.5.1.1 TCP

它將為每個TCP會話創建一個GoP。如果使用它，它應該是列表中的最后一個。TCP之上的所有其他原型都應使用*SStop=TRUE; *進行聲明 ，因此，在已經存在一個TCP PDU的地方就不會創建它。

Action=PduDef; Name=tcp_pdu; Proto=tcp; Transport=ip; addr=ip.addr; port=tcp.port; tcp_start=tcp.flags.syn; tcp_stop=tcp.flags.fin; tcp_stop=tcp.flags.reset;
Action=GopDef; Name=tcp_session; On=tcp_pdu; addr; addr; port; port;
Action=GopStart; For=tcp_session; tcp_start=1;
Action=GopStop; For=tcp_session; tcp_stop=1;

7.1.5.1.2 DNS

將創建一個包含每個請求及其響應的GoP（最終也會進行重傳）。

Action=PduDef; Name=dns_pdu; Proto=dns; Transport=udp/ip; addr=ip.addr; port=udp.port; dns_id=dns.id; dns_rsp=dns.flags.response;
Action=GopDef; Name=dns_req; On=dns_pdu; addr; addr; port!53; dns_id;
Action=GopStart; For=dns_req; dns_rsp=0;
Action=GopStop; For=dns_req; dns_rsp=1;

7.1.5.1.3 RADIUS

每筆交易都需要Gop。

Action=PduDef; Name=radius_pdu; Proto=radius; Transport=udp/ip; addr=ip.addr; port=udp.port; radius_id=radius.id; radius_code=radius.code;
Action=GopDef; Name=radius_req; On=radius_pdu; radius_id; addr; addr; port; port;
Action=GopStart; For=radius_req; radius_code|1|4|7;
Action=GopStop; For=radius_req; radius_code|2|3|5|8|9;

7.1.5.1.4 RTSP

Action=PduDef; Name=rtsp_pdu; Proto=rtsp; Transport=tcp/ip; addr=ip.addr; port=tcp.port; rtsp_method=rtsp.method;
Action=PduExtra; For=rtsp_pdu; rtsp_ses=rtsp.session; rtsp_url=rtsp.url;
Action=GopDef; Name=rtsp_ses; On=rtsp_pdu; addr; addr; port; port;
Action=GopStart; For=rtsp_ses; rtsp_method=DESCRIBE;
Action=GopStop; For=rtsp_ses; rtsp_method=TEARDOWN;
Action=GopExtra; For=rtsp_ses; rtsp_ses; rtsp_url;

7.1.5.2 VoIP/Telephony

除非另有說明，否則此處的大多數協議定義都會為每個呼叫分支創建一個Gop。

7.1.5.2.1 ISUP

Action=PduDef; Name=isup_pdu; Proto=isup; Transport=mtp3; mtp3pc=mtp3.dpc; mtp3pc=mtp3.opc; cic=isup.cic; isup_msg=isup.message_type;
Action=GopDef; Name=isup_leg; On=isup_pdu; ShowPduTree=TRUE; mtp3pc; mtp3pc; cic;
Action=GopStart; For=isup_leg; isup_msg=1;
Action=GopStop; For=isup_leg; isup_msg=16;

7.1.5.2.2 Q931

Action=PduDef; Name=q931_pdu; Proto=q931; Stop=TRUE; Transport=tcp/ip; addr=ip.addr; call_ref=q931.call_ref; q931_msg=q931.message_type;
Action=GopDef; Name=q931_leg; On=q931_pdu; addr; addr; call_ref;
Action=GopStart; For=q931_leg; q931_msg=5;
Action=GopStop; For=q931_leg; q931_msg=90;

7.1.5.2.3 H225 RAS

Action=PduDef; Name=ras_pdu; Proto=h225.RasMessage; Transport=udp/ip; addr=ip.addr; ras_sn=h225.RequestSeqNum; ras_msg=h225.RasMessage;
Action=PduExtra; For=ras_pdu; guid=h225.guid;
Action=GopDef; Name=ras_leg; On=ras_pdu; addr; addr; ras_sn;
Action=GopStart; For=ras_leg; ras_msg|0|3|6|9|12|15|18|21|26|30;
Action=GopStop; For=ras_leg; ras_msg|1|2|4|5|7|8|10|11|13|14|16|17|19|20|22|24|27|28|29|31;
Action=GopExtra; For=ras_leg; guid;

7.1.5.2.4 SIP

Action=PduDef; Proto=sip_pdu; Transport=tcp/ip; addr=ip.addr; port=tcp.port; sip_method=sip.Method; sip_callid=sip.Call-ID; calling=sdp.owner.username;
Action=GopDef; Name=sip_leg; On=sip_pdu; addr; addr; port; port;
Action=GopStart; For=sip; sip_method=INVITE;
Action=GopStop; For=sip; sip_method=BYE;

7.1.5.2.5 MEGACO

將在每筆交易中創建一個Gop。

To “tie” them to your call’s GoG use: Action=GogKey; Name=your_call; On=mgc_tr; addr!mgc_addr; megaco_ctx;

Action=PduDef; Name=mgc_pdu; Proto=megaco; Transport=ip; addr=ip.addr; megaco_ctx=megaco.context; megaco_trx=megaco.transid; megaco_msg=megaco.transaction; term=megaco.termid;
Action=GopDef; Name=mgc_tr; On=mgc_pdu; addr; addr; megaco_trx;
Action=GopStart; For=mgc_tr; megaco_msg|Request|Notify;
Action=GopStop; For=mgc_tr; megaco_msg=Reply;
Action=GopExtra; For=mgc_tr; term^DS1; megaco_ctx!Choose one;

7.1.6 MATE的參考手冊

7.1.6.1 Attribute Value Pairs

MATE幾乎所有內容都使用AVP：保留從幀樹中提取的數據以及保留配置元素。

這些”pairs”（實際上是元組）由名稱，值和（在配置AVP的情況下）運算符組成。名稱和值是字符串。運算符不是’=’的AVP僅在配置中使用，并且在分析階段用于匹配Pdu，GoP和GoG的AVP。

7.1.6.1.1 Name

名稱是用于引用AVP類的字符串。除非兩個屬性的名稱相同，否則兩個屬性將不匹配。大寫的名稱保留給關鍵字使用（如果需要，可以將它們用作元素，但我認為并非如此）。可以在Wireshark的顯示篩選器中使用MATE屬性名稱，就像解剖器提供的協議字段名稱一樣，但是它們不僅是對協議字段（或別名）的引用。

7.1.6.1.2 Value

該值是一個字符串。它既可以在配置中設置（用于配置AVP），也可以通過MATE設置，同時從解剖樹中提取有趣的字段并/或稍后對其進行操作。從字段中提取的值使用與過濾字符串中相同的表示形式。

7.1.6.1.3 Operators

當前僅定義了匹配運算符（有計劃（重新）添加轉換屬性，但在此之前必須解決一些內部問題）。匹配操作始終在兩個操作數之間執行：配置中規定的AVP值和從分組數據（稱為“數據AVP”）提取的AVP（或多個具有相同名稱的AVP）的值。數據AVP之間無法相互匹配。

定義的匹配運算符為：

• Equal =測試是否相等，即：要么值字符串相同，否則匹配將失敗。
• Not Equal ！僅當值字符串不相等時才匹配。
• One Of {}將匹配，如果上市值字符串中的一個等于數據AVP的字符串。大括號內的列表的各個項目使用 |分隔字符。
• Starts With ^如果配置值的字符串數據AVP的值字符串的第一個字符匹配將匹配。
• Ends With $如果配置值的字符串數據AVP的值字符串的最后一個字符匹配將匹配。
• Contains? 如果配置值字符串與數據AVP的值字符串的字符的子字符串匹配。
• Lower Than<如果數據AVP的值字符串在語義上低于配置值字符串
• Higher Than>如果數據AVP的值字符串在語義上高于配置值字符串
• Exists ？（可以省略）如果AVP名稱匹配，則無論值字符串是什么都將匹配

7.1.6.1.3.1 Equal AVP Operator

此運算符測試運算符和操作數AVP的值是否相等。

Example

attrib=aaa matches attrib=aaa attrib=aaa does not match attrib=bbb

7.1.6.1.3.2 Not equal AVP operator

如果兩個AVP的值字符串不相等，則此運算符匹配。

Example

attrib=aaa matches attrib!bbb attrib=aaa does not match attrib!aaa

7.1.6.1.3.3 “One of” AVP operator

如果數據AVP值等于”one of” AVP中列出的值之一，則”one of” 運算符匹配。

Example

attrib=1 matches attrib{1|2|3} attrib=2 matches attrib{1|2|3} attrib=4 does not match attrib{1|2|3}

7.1.6.1.3.4 “Starts with” AVP operator

如果數據AVP值的第一個字符與配置AVP值相同，則”starts with” 運算符匹配。

Example

attrib=abcd matches attrib^abc attrib=abc matches attrib^abc attrib=ab does not match attrib^abc attrib=abcd does not match attrib^bcd attrib=abc does not match attrib^abcd

7.1.6.1.3.5 “Ends with” operator

如果數據AVP值的最后一個字節等于配置AVP值，則以運營商結尾將匹配。

Example

attrib=wxyz matches attrib$xyz attrib=yz does not match attrib$xyz attrib=abc…?wxyz does not match attrib$abc

7.1.6.1.3.6 Contains operator

如果數據AVP值包含與配置AVP值相同的字符串，則 “contains” 運算符將匹配。

Example

7.1.6.1.3.7 “Lower than” operator

如果數據AVP值在語義上低于配置AVP值，則 “lower than”運算符將匹配。

Example

attrib=abc matches attrib<bcd attrib=1 matches attrib<2 but beware: attrib=10 does not match attrib<9 attrib=bcd does not match attrib<abc attrib=bcd does not match attrib<bcd

BUGS

它應該檢查值是否為數字，并進行數字比較

7.1.6.1.3.8 “Higher than” operator

如果數據AVP值在語義上高于配置AVP值，則”Higher than”運算符將匹配。

Example

attrib=bcd matches attrib>abc attrib=3 matches attrib>2 but beware: attrib=9 does not match attrib>10 attrib=abc does not match attrib>bcd attrib=abc does not match attrib>abc

BUGS

它應該檢查值是否為數字，并進行數字比較

7.1.6.1.3.9 Exists operator

存在的運算符將始終匹配，只要兩個操作數具有相同的名稱即可。

Example

attrib=abc matches attrib? attrib=abc matches attrib (this is just an alternative notation of the previous example) obviously attrib=abc does not match other_attrib?

7.1.6.2 Attribute/Value Pair List (AVPL)

Pdu，GoP和GoG使用AVPL來包含跟蹤信息。AVPL是可以與其他AVPL匹配的一組未排序的AVP。

7.1.6.2.1 AVPL之間的操作

在AVPL之間可以執行三種匹配操作。Pdu / GoP / GoG的AVPL將始終是操作數之一；AVPL運算符（匹配類型）和第二個操作數AVPL將始終來自 配置。注意，可以為配置AVPL中的每個AVP指定一個多樣化的AVP匹配運算符。

AVPL匹配操作返回結果AVPL。在Transform中，結果AVPL可以被另一個AVPL代替。更換裝置，現有的數據的AVP被丟棄，從所述替換AVPL 配置]被合并到PDU /的GoP / GOG的數據AVPL。

• Loose Match：如果兩個操作數AVPL的AVP至少之一匹配，則將匹配。如果匹配，則返回結果AVPL，其中包含與配置的AVP匹配的數據AVPL中的所有AVP。
• “Every” Match：如果配置AVPL的所有AVP都不匹配數據AVPL中的AVP，即使不是所有配置AVP都有匹配，也將匹配。如果匹配，則返回結果AVPL，其中包含與配置AVPL中的AVP匹配的數據AVPL中的所有AVP。
• Strict Match：僅當配置AVPL中的每個AVP在數據AVPL中至少具有一個匹配項時，才會匹配。如果匹配，則返回結果AVPL，其中包含來自匹配數據AVPL的那些AVP。

7.1.6.2.1.1 Loose Match

如果至少一個數據AVP與至少一個配置AVP相匹配，則AVPL之間的Loose Match成功。其結果AVPL包含所有匹配的數據AVP。

松散匹配用于針對PDU的AVPL的額外操作，以將結果合并到GOP的AVPL，并針對GOP的AVPL，以將結果合并到Gog的AVPL。它們也可以用在Criteria and Transforms中。

例子:

(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Loose (attr_a?, attr_c?) =? (attr_a=aaa, attr_c=xxx)
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Loose (attr_a?, attr_c=ccc) =? (attr_a=aaa)
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Loose (attr_a=xxx; attr_c=ccc) =? No Match!

7.1.6.2.1.2 Every Match

如果在數據AVPL中有對應項的配置的AVP均不匹配，則AVPL之間的 “every” 匹配都會成功。其結果AVPL包含所有匹配的數據AVP。

這些只能在Criteria和 Transform中使用。

示例

ttr_a=aaa, attr_b=bbb, attr_c=xxx) Match Every (attr_a?, attr_c?) =? (attr_a=aaa, attr_c=xxx)
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Every (attr_a?, attr_c?, attr_d=ddd) =? (attr_a=aaa, attr_c=xxx)
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Every (attr_a?, attr_c=ccc) =? No Match!
(attr_a=aaa; attr_b=bbb; attr_c=xxx) Match Every (attr_a=xxx, attr_c=ccc) =? No Match!

7.1.6.2.1.3 Strict Match

僅當配置AVPL中的每個AVP在數據AVPL中至少有一個對應項并且AVP匹配均不失敗時，AVPL之間的Strict Match成功。結果AVPL包含所有匹配的數據AVP。

這些用于Gop鍵（鍵AVPL）和Pdu AVPL之間。它們也可以在Criteria和 Transform中使用。

例子

attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Strict (attr_a?, attr_c=xxx) =? (attr_a=aaa, attr_c=xxx)
(attr_a=aaa, attr_b=bbb, attr_c=xxx, attr_c=yyy) Match Strict (attr_a?, attr_c?) =? (attr_a=aaa, attr_c=xxx, attr_c=yyy)
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Strict (attr_a?, attr_c=ccc) =? No Match!
(attr_a=aaa, attr_b=bbb, attr_c=xxx) Match Strict (attr_a?, attr_c?, attr_d?) =? No Match!

7.1.6.2.1.4 AVPL Merge

一個AVPL可以合并到另一個。這將為后者增加前者尚不存在的每個AVP。

該操作完成

• 在密鑰匹配結果和Gop’ or Gog’ AVPL之間，
• 在Extra比賽的結果和Gop’ or Gog’ AVPL之間，
• Transform匹配 的結果和Gop’ or Gog’ AVPL之間。如果Match子句指定的操作為Replace，則在將Modify_avpl合并到項目的AVPL中之前，將匹配結果AVPL從該項目的AVPL中刪除。

例子

(attr_a=aaa, attr_b=bbb) Merge (attr_a=aaa, attr_c=xxx) former becomes (attr_a=aaa, attr_b=bbb, attr_c=xxx)
(attr_a=aaa, attr_b=bbb) Merge (attr_a=aaa, attr_a=xxx) former becomes (attr_a=aaa, attr_a=xxx, attr_b=bbb)
(attr_a=aaa, attr_b=bbb) Merge (attr_c=xxx, attr_d=ddd) former becomes (attr_a=aaa, attr_b=bbb, attr_c=xxx, attr_d=ddd)

7.1.6.2.1.5 Transforms

Transforms是一系列的匹配規則，可選的后面是一條指令，說明如何使用附加的AVPL修改匹配結果。此類修改可以是 Insert (merge) or a Replace。語法如下：

Transform name {
    Match [Strict|Every|Loose] match_avpl [[Insert|Replace] modify_avpl] ; // may occur multiple times, at least once
};

轉換中的匹配規則列表從上到下進行處理；只要匹配規則成功或全部嘗試無效，處理就會結束。

可以在對象進一步處理之前將變換用作輔助操作該對象的AVPL。一個項目聲明可以包含一個Transform子句，該子句指示先前聲明的Transforms的列表。無論單個轉換是成功還是失敗，列表始終會完全按照給定的順序執行，即從左到右。

在MATE配置文件中，必須先聲明一個Transform，然后再聲明使用它的任何項目。

7.1.7 配置AVPL

7.1.7.1 Pdsu的配置操作

以下配置AVPL處理PDU創建和數據提取。

7.1.7.1.1 Pdu declaration block header

在捕獲的每個幀中，MATE都會按照聲明在其配置中出現的順序查找源proto_name的PDU，并會從該幀中創建各種類型的Pdu，除非特別指示某些Pdu類型是最后一個在框架中尋找一個。如果告知給定類型，則MATE將提取該類型的所有Pdu及其在幀中找到的先前聲明的類型，但不提取以后聲明的類型。

Pdu的完整聲明如下所示；各種條款的強制性順序如下所示。

Pdu name Proto proto_name Transport proto1[/proto2/proto3[/...]]] {
      Payload proto; //optional, no default value
      Extract attribute From proto.field ; //may occur multiple times, at least once
      Transform (transform1[, transform2[, ...]]); //optional
      Criteria [{Accept|Reject}] [{Strict|Every|Loose} match_avpl];
      DropUnassigned {true|false}; //optional, default=false
      DiscardPduData {true|false}; //optional, default=false
      LastExtracted {true|false}; //optional, default=false
    };

7.1.7.1.2 Pdu name

該name是Pdu聲明的必需屬性。它是任意選擇的，除了每個name只能在MATE的配置中使用一次，而與它所使用的項目的類別無關。該name用于區分不同類型的Pdu，Gop和Gogs。該name 還用作與MATE創建的這種Pdu類型相關的可過濾字段名稱的一部分。

但是，幾個Pdu聲明可能共享相同的name。在這種情況下，它們都是從與它們的Proto，Transport和Payload子句匹配的每個源PDU創建的，而它們的聲明的主體可能彼此完全不同。當需要根據其他源字段的內容（或僅存在）從不同的源字段集構建Pdu的AVPL時，此功能與Accept（或Reject）子句一起使用非常有用。

7.1.7.1.2.1 原始條款和運輸條款

幀中協議proto_name PDU 的每個實例都將生成一個Pdu，該Pdu具有從proto_name’s range和/或Transport list指定的基礎協議范圍內的字段中提取的AVP 。它是Pdu聲明的必需屬性。該proto_name是該協議的名稱作為Wireshark的顯示過濾器使用。

Pdu的Proto及其協議的Transport list，用/分隔MATE，以告知幀的哪些字段可以進入Pdu的AVPL。為了使MATE從幀的協議樹中提取屬性，表示該幀的十六進制顯示中的字段的區域必須在 Proto或其相對Transport的區域內。選擇Transport s從協議區域按給定的順序向后移動。

Proto HTTP Transport tcp / ip會執行您期望的操作-它選擇當前http范圍之前的最近tcp范圍，以及該tcp范圍之前的最近ip范圍。如果在最接近的IP范圍之前還有另一個ip范圍（例如，在IP隧道的情況下），則不會選擇該范圍。 到目前為止， “logically” 也應該選擇封裝IP標頭的Transport tcp/ip/ip無法正常工作。

一旦選擇了Proto和Transport范圍，MATE將獲取屬于它們的那些協議字段，這些字段的提取使用Pdu類型的Extract子句聲明 。在Transport list也是強制性的，如果你真的不希望使用任何傳輸協議，使用Transport mate。（This didn’t work until 0.10.9）。

7.1.7.1.2.2 有效載荷條款

除了Pdu的Proto及其Transport協議以外，還有一個 Payload屬性，用于告知MATE MATE從Proto的有效載荷范圍中提取幀字段到Pdu中。為了從框架的樹中提取屬性，十六進制顯示中字段的突出顯示區域必須在Proto的相對有效載荷區域內。從協議區域開始按順序選擇Payload s *。 *Proto http Transport tcp/ip Payload mmse *將選擇當前http范圍之后的第一個mmse范圍。選擇了有效載荷后在范圍內，MATE將獲取屬于它們的那些協議字段，這些協議字段的提取使用Pdu類型的Extract*子句聲明。

7.1.7.1.2.3 提取條款

每個Extract子句告訴MATE將哪個協議字段值提取為AVP值，以及將什么字符串用作AVP名稱。使用Wireshark顯示過濾器中使用的名稱來引用協議字段。如果幀中有多個這樣的協議字段，則將滿足上述條件的每個實例提取到其自己的AVP中。可以任意選擇AVP名稱，但是為了能夠稍后在分析中匹配最初來自不同Pdu的值（例如，來自DNS查詢的主機名和來自HTTP GET請求的主機名），必須為它們分配相同的AVP名稱，并且剖析器必須以相同的格式提供字段值。

7.1.7.1.2.4 轉換子句

該Transform的先前聲明子句指定列表Transform要在PDU的AVPL進行年代后所有協議字段已被提取到它。該列表始終從左到右完整執行。相反，每個Transform內部的Match子句列表僅在第一個匹配成功之前執行。

7.1.7.1.2.5 條件條款

此子句告訴MATE是否使用Pdu進行分析。它指定一個匹配AVPL，一個AVPL匹配類型（Strict，Every或Loose）以及如果匹配成功將要執行的操作（Accept或Reject）。一旦提取了每個屬性并執行了最終的轉換列表，并且存在 Criteria子句，則將Pdu的AVPL與匹配的AVPL進行匹配；如果匹配成功，則執行指定的操作，即接受或拒絕Pdu。如果省略各個關鍵字，則默認行為是Strict和Accept。因此，如果省略該子句，則接受所有Pdu。

7.1.7.1.2.6 DropUnassigned子句

如果設置為TRUE，則MATE如果無法將其分配給Gop，則將銷毀Pdu。如果設置為FALSE（默認值，則未指定），MATE將保留它們。

7.1.7.1.2.7 DiscardPduData子句

如果設置為TRUE，則MATE在分析了Pdu的AVPL后將刪除它，并最終從其中提取一些AVP到Gop的AVPL中。這對于節省內存（MATE使用很多內存）很有用。如果設置為FALSE（默認值，則未指定），MATE將保留Pdu屬性。

7.1.7.1.2.8 LastExtracted子句

如果設置為FALSE（默認值，則未指定），MATE將繼續在框架中查找其他類型的Pdu。如果設置為TRUE，它將不會嘗試從當前幀創建其他類型的Pdu，但是它將繼續嘗試使用當前類型。

7.1.7.1.3 Gop的配置動作

7.1.7.1.3.1 Gop聲明塊標頭

聲明Gop類型及其預匹配候選鍵。

Gop name On pduname Match key {
      Start match_avpl; // optional
      Stop match_avpl; // optional
      Extra match_avpl; // optional
      Transform transform_list; // optional
      Expiration time; // optional
      IdleTimeout time; // optional
      Lifetime time; // optional
      DropUnassigned [TRUE|FALSE]; //optional
      ShowTree [NoTree|PduTree|FrameTree|BasicTree]; //optional
      ShowTimes [TRUE|FALSE]; //optional, default TRUE
    };

7.1.7.1.3.2 Gop名稱

該name是GOP的聲明的強制屬性。它是任意選擇的，除了每個name只能在MATE的配置中使用一次，而與它所使用的項目的類別無關。該name用于區分不同類型的Pdu，Gop和Gogs。該name 還用作與MATE創建的這種類型的Gop相關的可過濾字段名稱的一部分。

7.1.7.1.3.3 On clause

該name這種類型GOP的假定的PDU被groupping。這是強制性的。

7.1.7.1.3.4 Match clause

定義哪些AVP構成Gop的AVPL 的key部分（Gop的key AVPL或簡稱為Gop的key）。與活動Gop 的key AVPL匹配的所有Pdu 都分配給該Gop；包含屬性名稱列在Gop的key AVPL中但與活動的Gop的key AVPL 不嚴格匹配的AVP的Pdu 將創建一個新的Gop（除非指定了Start子句）。創建Gop時，會從創建的Pdu中復制其關鍵AVPL的元素。

7.1.7.1.3.5 Match clause

如果給出，它會告訴MATE除了匹配Gop的key之外，還必須Pdu的AVPL匹配match_avpl 才能啟動Gop。如果未給出，則其AVPL與Gop的key AVPL匹配的任何Pdu 將充當Gop的起點。與match_avpl匹配的Pdu的AVP不會自動復制到Gop的AVPL中。

7.1.7.1.3.6 Stop clause

如果給出，它會告訴MATE除匹配Gop的key外，還必須Pdu的AVPL匹配Match_avpl的哪些內容才能停止Gop。如果省略，則Gop是”auto-stopped”-也就是說，一旦創建Gop，就會將其標記為已停止。與match_avpl匹配的Pdu的AVP不會自動復制到Gop的AVPL中。

7.1.7.1.3.7 Extra clause

如果給出，則告知MATE除了Gop的密鑰外，還將Pdu的AVPL中的哪些AVP復制到Gop的AVPL中。

7.1.7.1.3.8 Transform clause

該Transform子句指定列表的前面聲明Transform從每個新PDU中的AVP，通過密鑰AVPL和指定后共和黨的AVPL要執行小號Extra clause’s match_avpl，已經被合并到它。該列表始終從左到右完整執行。相反，每個Transform內部的Match子句列表僅在第一個匹配成功之前執行。

7.1.7.1.3.9 Expiration clause

GOP停止后的(浮動)秒數，在此期間，與停止的GOP的鍵匹配但不符合啟動條件的其他PDU仍將分配給該GOP。默認值零具有無限的實際含義，因為它禁用此計時器，因此所有與停止的GOP的鍵匹配的PDU都將分配給該GOP，除非它們與啟動條件匹配。

7.1.7.1.3.10 IdleTimeout clause

從分配給Gop的最后一個Pdu開始經過的（浮動）秒數，之后該Gop將被視為已釋放。默認值零實際上是無窮大，因為它會禁用此計時器，因此即使沒有Pdu到達，也不會釋放Gop-除非Lifetime計時器到期。

7.1.7.1.3.11 Lifetime clause

Gop 啟動后的幾秒鐘（浮動），之后無論其他任何情況，都會認為Gop已釋放。默認值為零，其實際含義是無窮大。

7.1.7.1.3.12 DropUnassigned子句

是否應將尚未分配給任何Gog的Gop丟棄。如果為TRUE，則會在創建后立即丟棄Gop。如果為FALSE（默認值），則保留未分配的Gop。將其設置為TRUE有助于節省內存并加快過濾速度。

7.1.7.1.3.13 TreeMode子句

控制Gop的Pdus子樹的顯示：

• NoTree: completely suppresses showing the tree
• PduTree: the tree is shown and shows the Pdus by Pdu Id
• FrameTree: the tree is shown and shows the Pdus by the frame number in which they are
• BasicTree: needs investigation

7.1.7.1.3.14 ShowTimes子句

是否顯示Gop的次子樹。如果為TRUE（默認），則帶有計時器的子樹將添加到Gop的樹中。如果為FALSE，則抑制子樹。

7.1.7.1.4 Gog的配置操作

7.1.7.1.4.1 Gop聲明塊標頭

聲明Gog類型及其預匹配候選鍵。

Declares a Gog type and its prematch candidate key.

    Gog name {
      Member gopname (key); // mandatory, at least one
      Extra match_avpl; // optional
      Transform transform_list; // optional
      Expiration time; // optional, default 2.0
      GopTree [NoTree|PduTree|FrameTree|BasicTree]; // optional
      ShowTimes [TRUE|FALSE]; // optional, default TRUE
    };

7.1.7.1.4.2 Gop名稱

該name是Gog聲明的強制屬性。它是任意選擇的，除了每個name只能在MATE的配置中使用一次，而與它所使用的項目的類別無關。該name用于區分不同類型的Pdu，Gop和Gogs。該name 還用作與MATE創建的這種類型的Gop相關的可過濾字段名稱的一部分。

7.1.7.1.4.3 Member clause

為每個GOP類型Gopname分別定義GOG的密鑰AVPL。其關鍵字AVPL與活動GOG的對應關鍵字AVPL匹配的所有Gopname類型GOP被分配給該GOG；包含其屬性名稱列在GOG的相應關鍵字AVPL中但它們不嚴格匹配任何活動GOG的關鍵字AVPL的AVP的GOP將創建新的GOG。創建GoG時，將從創建GOP復制其密鑰AVPL的元素。

盡管為每個成員Gopname分別指定了密鑰AVPLS，但在大多數情況下它們是相同的，因為GOG的目的就是將由不同類型的PDU組成的GOP分組在一起。

7.1.7.1.4.4 到期條款

釋放分配給Gog的所有Gops之后的（浮動）秒數，在此期間，仍應將與任何會話密鑰匹配的新Gops分配給現有Gog，而不是創建新的Gop。其值的范圍可以從0.0到無窮大。默認為2.0秒。

7.1.7.1.4.5 轉換子句

Transform子句指定在每個新GOP的AVP(由鍵AVPL和額外子句的Match_avpl指定)合并到GOG的AVPL之后，要在GOG的AVPL上執行的先前聲明的轉換的列表。該列表始終從左到右完全執行。相反，每個單獨轉換內的匹配子句列表僅在第一個匹配成功之前執行。

7.1.7.1.4.6 TreeMode子句

控制Gog的Gops子樹的顯示：

• NoTree: completely suppresses showing the tree
• BasicTree: needs investigation
• FullTree: needs investigation

7.1.7.1.4.7 ShowTimes子句

是否顯示Gog的次子樹。如果為TRUE（默認），則帶有計時器的子樹將添加到Gog的樹中。如果為FALSE，則抑制子樹。

7.1.7.1.5 設置配置AVPL

所述Settings配置元件用于傳遞到MATE各種操作參數。可能的參數是

7.1.7.1.5.1 GogExpiration

釋放分配給gog的所有gop后幾秒鐘后，匹配任何會話密鑰的新gop應該創建一個新gog，而不是分配給前一個gog。其值的范圍可以從0.0到無窮大。默認為2.0秒。

7.1.7.1.5.2 DiscardPduData

在處理每個Pdu的AVPL之后是否應該刪除它（節省內存）。它可以是TRUE或FALSE。默認為TRUE。如果您的配置不起作用，將其設置為FALSE可以使您免于頭痛。

7.1.7.1.5.3 DiscardUnassignedPdu

如果未將Pdu分配給任何Gop，是否應刪除它們。它可以是TRUE或FALSE。默認為FALSE。如果未分配的Pdu沒用，請將其設置為TRUE以節省內存。

7.1.7.1.5.4 DiscardUnassignedGop

如果未分配GoP，則是否應刪除它們。它可以是TRUE或FALSE。默認為FALSE。將其設置為TRUE可節省內存。

7.1.7.1.5.5 ShowPduTree

7.1.7.1.5.6 ShowGopTimes

7.1.7.1.6 DiscardUnassignedGop

以下設置用于調試MATE及其配置。所有級別都是整數，范圍從0（print only errors）到9（lood me with junk），默認為0。

7.1.7.1.6.1 Debug declaration block header

Debug {
      Filename "path/name"; //optional, no default value
      Level [0-9]; //optional, generic debug level
      Pdu Level [0-9]; //optional, specific debug level for Pdu handling
      Gop Level [0-9]; //optional, specific debug level for Gop handling
      Gog Level [0-9]; //optional, specific debug level for Gog handling
    };

7.1.7.1.6.2 Filename clause

{{{path/name}}} 是要向其寫入調試輸出的文件的完整路徑。將創建不存在的文件，在每次打開捕獲文件時將覆蓋現有文件。如果缺少該語句，調試消息將寫入控制臺，這意味著它們在Windows上不可見。

7.1.7.1.6.3 Level clause

設置通用調試消息的調試級別。它是一個整數，范圍從0（print only errors）到9（lood me with junk）。

7.1.7.1.6.4 Pdu Level clause

設置有關Pdu創建的消息的調試級別。它是一個整數，范圍從0（print only errors）到9（lood me with junk）。

7.1.7.1.6.5 Gop Level子句

設置有關Pdu分析的消息的調試級別（也就是說，它們如何適合于GoPs）。它是一個整數，范圍從0（print only errors）到9（lood me with junk）。

7.1.7.1.6.6 Gog Level條款

設置有關GoP分析的消息的調試級別（這就是它們如何適合于GoGs）。它是一個整數，范圍從0（print only errors）到9（lood me with junk）。

7.1.7.1.6.7 設定范例

Action=Settings; SessionExpiration=3.5; DiscardPduData=FALSE;

7.1.7.1.7 Action=Include

將包括一個配置文件。

Action=Include; {Filename=filename;|Lib=libname;}

7.1.7.1.7.1 Filename

要包含的文件的文件名。如果它不以’/‘開頭，它將在當前路徑中查找文件。

7.1.7.1.7.2 Lib

要包含的庫配置名稱。會在wiresharks_dir / matelib中尋找libname.mate。

7.1.7.1.7.3 Include Example

Action=Include; Filename=rtsp.mate;

這會將名為“ rtsp.mate”的文件包含到當前配置中。