1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
|
/* packet-scriptingservice.c
* Routines for the Scripting Service Protocol, a load distribution application
* of the rsplib RSerPool implementation
* http://tdrwww.iem.uni-due.de/dreibholz/rserpool/
*
* Copyright 2008-2010 by Thomas Dreibholz <dreibh [AT] iem.uni-due.de>
*
* Wireshark - Network traffic analyzer
* By Gerald Combs <gerald@wireshark.org>
* Copyright 1998 Gerald Combs
*
* SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "config.h"
#include <epan/packet.h>
#include <epan/sctpppids.h>
#define SSPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY 0x29097604
void proto_register_ssprotocol(void);
void proto_reg_handoff_ssprotocol(void);
/* Initialize the protocol and registered fields */
static int proto_ssprotocol = -1;
static int hf_message_type = -1;
static int hf_message_flags = -1;
static int hf_message_length = -1;
static int hf_message_status = -1;
static int hf_message_data = -1;
static int hf_message_reason = -1;
static int hf_message_info = -1;
static int hf_message_hash = -1;
static int hf_environment_u_bit = -1;
/* Initialize the subtree pointers */
static gint ett_ssprotocol = -1;
static gint ett_environment_flags = -1;
/* Dissectors for messages. This is specific to ScriptingServiceProtocol */
#define MESSAGE_TYPE_LENGTH 1
#define MESSAGE_FLAGS_LENGTH 1
#define MESSAGE_LENGTH_LENGTH 2
#define MESSAGE_STATUS_LENGTH 4
#define MESSAGE_NOTRDY_REASON_LENGTH 4
#define MESSAGE_ENVIRON_HASH_LENGTH 20
#define MESSAGE_TYPE_OFFSET 0
#define MESSAGE_FLAGS_OFFSET (MESSAGE_TYPE_OFFSET + MESSAGE_TYPE_LENGTH)
#define MESSAGE_LENGTH_OFFSET (MESSAGE_FLAGS_OFFSET + MESSAGE_FLAGS_LENGTH)
#define MESSAGE_STATUS_OFFSET (MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH)
#define MESSAGE_DATA_OFFSET (MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH)
#define MESSAGE_RDY_INFO_OFFSET (MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH)
#define MESSAGE_NOTRDY_REASON_OFFSET (MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH)
#define MESSAGE_NOTRDY_INFO_OFFSET (MESSAGE_NOTRDY_REASON_OFFSET + MESSAGE_NOTRDY_REASON_LENGTH)
#define MESSAGE_ENVIRON_HASH_OFFSET (MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH)
#define SS_NOTREADY_TYPE 0
#define SS_READY_TYPE 1
#define SS_UPLOAD_TYPE 2
#define SS_DOWNLOAD_TYPE 3
#define SS_KEEPALIVE_TYPE 4
#define SS_KEEPALIVE_ACK_TYPE 5
#define SS_STATUS_TYPE 6
#define SS_ENVIRONMENT_TYPE 7
static const value_string message_type_values[] = {
{ SS_NOTREADY_TYPE, "Not Ready" },
{ SS_READY_TYPE, "Ready" },
{ SS_UPLOAD_TYPE, "Upload" },
{ SS_DOWNLOAD_TYPE, "Download" },
{ SS_KEEPALIVE_TYPE, "Keep-Alive" },
{ SS_KEEPALIVE_ACK_TYPE, "Keep-Alive Ack" },
{ SS_STATUS_TYPE, "Status" },
{ SS_ENVIRONMENT_TYPE, "Environment" },
{ 0, NULL }
};
static const value_string notrdy_reason_values[] = {
{ 0x00000001, "Fully Loaded" },
{ 0x00000002, "Out of Resources" },
{ 0, NULL }
};
#define SSP_ENVIRONMENT_U_BIT 0x01
static const true_false_string environment_u_bit = {
"Upload needed",
"Upload not needed"
};
static guint
dissect_ssprotocol_message(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *ssprotocol_tree)
{
proto_item* flags_item;
proto_tree* flags_tree;
guint8 type;
guint16 data_length;
guint16 info_length;
guint total_length;
type = tvb_get_guint8(message_tvb, MESSAGE_TYPE_OFFSET);
col_add_fstr(pinfo->cinfo, COL_INFO, "%s ", val_to_str(type, message_type_values, "Unknown SSP type: %u"));
proto_tree_add_item(ssprotocol_tree, hf_message_type, message_tvb, MESSAGE_TYPE_OFFSET, MESSAGE_TYPE_LENGTH, ENC_BIG_ENDIAN);
flags_item = proto_tree_add_item(ssprotocol_tree, hf_message_flags, message_tvb, MESSAGE_FLAGS_OFFSET, MESSAGE_FLAGS_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(ssprotocol_tree, hf_message_length, message_tvb, MESSAGE_LENGTH_OFFSET, MESSAGE_LENGTH_LENGTH, ENC_BIG_ENDIAN);
total_length = MESSAGE_LENGTH_OFFSET + MESSAGE_LENGTH_LENGTH;
switch (type) {
case SS_KEEPALIVE_ACK_TYPE:
case SS_STATUS_TYPE:
info_length = tvb_get_ntohs(message_tvb, MESSAGE_LENGTH_OFFSET) - MESSAGE_STATUS_OFFSET;
if (info_length == MESSAGE_STATUS_LENGTH) {
proto_tree_add_item(ssprotocol_tree, hf_message_status, message_tvb, MESSAGE_STATUS_OFFSET, MESSAGE_STATUS_LENGTH, ENC_BIG_ENDIAN);
total_length += MESSAGE_STATUS_LENGTH;
}
break;
case SS_UPLOAD_TYPE:
case SS_DOWNLOAD_TYPE:
data_length = tvb_get_ntohs(message_tvb, MESSAGE_LENGTH_OFFSET) - MESSAGE_DATA_OFFSET;
if (data_length > 0) {
proto_tree_add_item(ssprotocol_tree, hf_message_data, message_tvb, MESSAGE_DATA_OFFSET, data_length, ENC_NA);
total_length += data_length;
}
break;
case SS_READY_TYPE:
info_length = tvb_get_ntohs(message_tvb, MESSAGE_LENGTH_OFFSET) - MESSAGE_RDY_INFO_OFFSET;
if (info_length > 0) {
proto_tree_add_item(ssprotocol_tree, hf_message_info, message_tvb, MESSAGE_RDY_INFO_OFFSET, info_length, ENC_ASCII|ENC_NA);
total_length += info_length;
}
break;
case SS_NOTREADY_TYPE:
info_length = tvb_get_ntohs(message_tvb, MESSAGE_LENGTH_OFFSET) - MESSAGE_NOTRDY_INFO_OFFSET;
if (info_length > 0) {
proto_tree_add_item(ssprotocol_tree, hf_message_reason, message_tvb, MESSAGE_NOTRDY_REASON_OFFSET, MESSAGE_NOTRDY_REASON_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(ssprotocol_tree, hf_message_info, message_tvb, MESSAGE_NOTRDY_INFO_OFFSET, info_length, ENC_ASCII|ENC_NA);
total_length += info_length;
}
break;
case SS_ENVIRONMENT_TYPE:
flags_tree = proto_item_add_subtree(flags_item, ett_environment_flags);
proto_tree_add_item(flags_tree, hf_environment_u_bit, message_tvb, MESSAGE_FLAGS_OFFSET, MESSAGE_FLAGS_LENGTH, ENC_BIG_ENDIAN);
proto_tree_add_item(ssprotocol_tree, hf_message_hash, message_tvb, MESSAGE_ENVIRON_HASH_OFFSET, MESSAGE_ENVIRON_HASH_LENGTH, ENC_NA);
break;
default:
break;
}
return total_length;
}
static int
dissect_ssprotocol(tvbuff_t *message_tvb, packet_info *pinfo, proto_tree *tree, void *data _U_)
{
proto_item *ssprotocol_item;
proto_tree *ssprotocol_tree;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "SSP");
/* create the ssprotocol protocol tree */
ssprotocol_item = proto_tree_add_item(tree, proto_ssprotocol, message_tvb, 0, -1, ENC_NA);
ssprotocol_tree = proto_item_add_subtree(ssprotocol_item, ett_ssprotocol);
/* dissect the message */
return dissect_ssprotocol_message(message_tvb, pinfo, ssprotocol_tree);
}
/* Register the protocol */
void
proto_register_ssprotocol(void)
{
/* Setup list of header fields */
static hf_register_info hf[] = {
{ &hf_message_type, { "Type", "ssp.message_type", FT_UINT8, BASE_DEC, VALS(message_type_values), 0x0, NULL, HFILL } },
{ &hf_message_flags, { "Flags", "ssp.message_flags", FT_UINT8, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_length, { "Length", "ssp.message_length", FT_UINT16, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_status, { "Status", "ssp.message_status", FT_UINT32, BASE_DEC, NULL, 0x0, NULL, HFILL } },
{ &hf_message_reason, { "Reason", "ssp.message_reason", FT_UINT32, BASE_DEC, VALS(notrdy_reason_values), 0x0, NULL, HFILL } },
{ &hf_message_info, { "Info", "ssp.message_info", FT_STRING, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_message_data, { "Data", "ssp.message_data", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_message_hash, { "Hash", "ssp.message_hash", FT_BYTES, BASE_NONE, NULL, 0x0, NULL, HFILL } },
{ &hf_environment_u_bit, { "U-Bit", "ssp.environment_u_bit", FT_BOOLEAN, 8,TFS(&environment_u_bit), SSP_ENVIRONMENT_U_BIT, NULL, HFILL } }
};
/* Setup protocol subtree array */
static gint *ett[] = {
&ett_ssprotocol,
&ett_environment_flags
};
/* Register the protocol name and description */
proto_ssprotocol = proto_register_protocol("Scripting Service Protocol", "SSP", "ssp");
/* Required function calls to register the header fields and subtrees used */
proto_register_field_array(proto_ssprotocol, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
}
void
proto_reg_handoff_ssprotocol(void)
{
dissector_handle_t ssprotocol_handle;
ssprotocol_handle = create_dissector_handle(dissect_ssprotocol, proto_ssprotocol);
dissector_add_uint("sctp.ppi", SSPROTOCOL_PAYLOAD_PROTOCOL_ID_LEGACY, ssprotocol_handle);
dissector_add_uint("sctp.ppi", SSP_PAYLOAD_PROTOCOL_ID, ssprotocol_handle);
}
/*
* Editor modelines - http://www.wireshark.org/tools/modelines.html
*
* Local Variables:
* c-basic-offset: 2
* tab-width: 8
* indent-tabs-mode: nil
* End:
*
* ex: set shiftwidth=2 tabstop=8 expandtab:
* :indentSize=2:tabSize=8:noTabs=true:
*/
|
