Removed trailing whitespaces from .h and .c files using the
[obnox/wireshark/wip.git] / packet-quakeworld.c
1 /* packet-quakeworld.c
2  * Routines for QuakeWorld packet dissection
3  *
4  * Uwe Girlich <uwe@planetquake.com>
5  *      http://www.idsoftware.com/q1source/q1source.zip
6  *
7  * $Id: packet-quakeworld.c,v 1.15 2002/08/02 23:35:57 jmayer Exp $
8  *
9  * Ethereal - Network traffic analyzer
10  * By Gerald Combs <gerald@ethereal.com>
11  * Copyright 1998 Gerald Combs
12  *
13  * Copied from packet-quake.c
14  * 
15  * This program is free software; you can redistribute it and/or
16  * modify it under the terms of the GNU General Public License
17  * as published by the Free Software Foundation; either version 2
18  * of the License, or (at your option) any later version.
19  * 
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  * 
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, write to the Free Software
27  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
28  */
29
30 #ifdef HAVE_CONFIG_H
31 # include "config.h"
32 #endif
33
34 #include <glib.h>
35 #include <string.h>
36 #include <epan/packet.h>
37 #include "prefs.h"
38
39 static int proto_quakeworld = -1;
40
41 static int hf_quakeworld_s2c = -1;
42 static int hf_quakeworld_c2s = -1;
43 static int hf_quakeworld_connectionless = -1;
44 static int hf_quakeworld_game = -1;
45 static int hf_quakeworld_connectionless_marker = -1;
46 static int hf_quakeworld_connectionless_text = -1;
47 static int hf_quakeworld_connectionless_command = -1;
48 static int hf_quakeworld_connectionless_arguments = -1;
49 static int hf_quakeworld_connectionless_connect_version = -1;
50 static int hf_quakeworld_connectionless_connect_qport = -1;
51 static int hf_quakeworld_connectionless_connect_challenge = -1;
52 static int hf_quakeworld_connectionless_connect_infostring = -1;
53 static int hf_quakeworld_connectionless_connect_infostring_key_value = -1;
54 static int hf_quakeworld_connectionless_connect_infostring_key = -1;
55 static int hf_quakeworld_connectionless_connect_infostring_value = -1;
56 static int hf_quakeworld_connectionless_rcon_password = -1;
57 static int hf_quakeworld_connectionless_rcon_command = -1;
58 static int hf_quakeworld_game_seq1 = -1;
59 static int hf_quakeworld_game_rel1 = -1;
60 static int hf_quakeworld_game_seq2 = -1;
61 static int hf_quakeworld_game_rel2 = -1;
62 static int hf_quakeworld_game_qport = -1;
63
64 static gint ett_quakeworld = -1;
65 static gint ett_quakeworld_connectionless = -1;
66 static gint ett_quakeworld_connectionless_text = -1;
67 static gint ett_quakeworld_connectionless_arguments = -1;
68 static gint ett_quakeworld_connectionless_connect_infostring = -1;
69 static gint ett_quakeworld_connectionless_connect_infostring_key_value = -1;
70 static gint ett_quakeworld_game = -1;
71 static gint ett_quakeworld_game_seq1 = -1;
72 static gint ett_quakeworld_game_seq2 = -1;
73 static gint ett_quakeworld_game_clc = -1;
74 static gint ett_quakeworld_game_svc = -1;
75
76 static dissector_handle_t data_handle;
77
78 /*
79    helper functions, they may ave to go somewhere else
80    they are mostly copied without change from
81         quakeworldsource/client/cmd.c
82         quakeworldsource/client/common.c
83 */
84
85 #define MAX_TEXT_SIZE   2048
86
87 static  char            com_token[MAX_TEXT_SIZE+1];
88 static  int             com_token_start;
89 static  int             com_token_length;
90
91 static char *
92 COM_Parse (char *data)
93 {
94         int     c;
95         int     len;
96
97         len = 0;
98         com_token[0] = 0;
99         com_token_start = 0;
100         com_token_length = 0;
101
102         if (data == NULL)
103                 return NULL;
104
105         /* skip whitespace */
106 skipwhite:
107         while ( (c = *data) <= ' ') {
108                 if (c == 0)
109                         return NULL;    /* end of file; */
110                 data++;
111                 com_token_start++;
112         }
113
114         /* skip // comments */
115         if (c=='/' && data[1] == '/') {
116                 while (*data && *data != '\n')
117                         data++;
118                         com_token_start++;
119                 goto skipwhite;
120         }
121
122         /* handle quoted strings specially */
123         if (c == '\"') {
124                 data++;
125                 com_token_start++;
126                 while (1) {
127                         c = *data++;
128                         if (c=='\"' || c==0) {
129                                 com_token[len] = 0;
130                                 return data;
131                         }
132                         com_token[len] = c;
133                         len++;
134                         com_token_length++;
135                 }
136         }
137
138         /* parse a regular word */
139         do {
140                 com_token[len] = c;
141                 data++;
142                 len++;
143                 com_token_length++;
144                 c = *data;
145         } while (c>32);
146
147         com_token[len] = 0;
148         return data;
149 }
150
151
152 #define                 MAX_ARGS 80
153 static  int             cmd_argc = 0;
154 static  char            *cmd_argv[MAX_ARGS];
155 static  char            *cmd_null_string = "";
156 static  int             cmd_argv_start[MAX_ARGS];
157 static  int             cmd_argv_length[MAX_ARGS];
158
159
160
161 static int
162 Cmd_Argc(void)
163 {
164         return cmd_argc;
165 }
166
167
168 static char*
169 Cmd_Argv(int arg)
170 {
171         if ( arg >= cmd_argc )
172                 return cmd_null_string;
173         return cmd_argv[arg];
174 }
175
176
177 static int
178 Cmd_Argv_start(int arg)
179 {
180         if ( arg >= cmd_argc )
181                 return 0;
182         return cmd_argv_start[arg];
183 }
184
185
186 static int
187 Cmd_Argv_length(int arg)
188 {
189         if ( arg >= cmd_argc )
190                 return 0;
191         return cmd_argv_length[arg];
192 }
193
194
195 static void
196 Cmd_TokenizeString(char* text)
197 {
198         int i;
199         int start;
200         int length;
201         
202
203         /* clear the args from the last string */
204         for (i=0 ; i<cmd_argc ; i++)
205                 g_free(cmd_argv[i]);
206
207         cmd_argc = 0;
208
209         start = 0;
210         while (TRUE) {
211
212                 /* skip whitespace up to a \n */
213                 while (*text && *text <= ' ' && *text != '\n') {
214                         text++;
215                         start++;
216                 }
217
218                 length = 0;
219
220                 if (*text == '\n') {
221                         /* a newline seperates commands in the buffer */
222                         text++;
223                         break;
224                 }
225
226                 if (!*text)
227                         return;
228                         
229                 text = COM_Parse (text);
230                 if (!text)
231                         return;
232
233                 if (cmd_argc < MAX_ARGS) {
234                         cmd_argv[cmd_argc] = g_strdup(com_token);
235                         cmd_argv_start[cmd_argc] = start + com_token_start;
236                         cmd_argv_length[cmd_argc] = com_token_length;
237                         cmd_argc++;
238                 }
239
240                 start += com_token_start + com_token_length;
241         }
242 }
243
244                         
245 static void
246 dissect_id_infostring(tvbuff_t *tvb, proto_tree* tree, 
247         int offset, char* infostring,
248         gint ett_key_value, int hf_key_value, int hf_key, int hf_value)
249 {
250         char * newpos = infostring;
251         int end_of_info = FALSE;
252
253         /* to look at all the key/value pairs, we destroy infostring */
254         while(!end_of_info) {
255                 char* keypos;
256                 char* valuepos;
257                 int keylength;
258                 char* keyvaluesep;
259                 int valuelength;
260                 char* valueend;
261
262                 keypos = newpos;
263                 if (*keypos == 0) break;
264                 if (*keypos == '\\') keypos++;
265
266                 for (keylength = 0
267                         ;
268                         *(keypos + keylength) != '\\' && 
269                         *(keypos + keylength) != 0
270                         ;
271                         keylength++) ;
272                 keyvaluesep = keypos + keylength;
273                 if (*keyvaluesep == 0) break;
274                 valuepos = keyvaluesep+1;
275                 for (valuelength = 0
276                         ;
277                         *(valuepos + valuelength) != '\\' && 
278                         *(valuepos + valuelength) != 0
279                         ;
280                         valuelength++) ;
281                 valueend = valuepos + valuelength;
282                 if (*valueend == 0) {
283                         end_of_info = TRUE;
284                 }
285                 *(keyvaluesep) = '=';
286                 *(valueend) = 0;
287                 
288                 if (tree) {
289                         proto_item* sub_item = NULL;
290                         proto_tree* sub_tree = NULL;
291
292                         sub_item = proto_tree_add_string(tree,
293                                 hf_key_value,
294                                 tvb,
295                                 offset + (keypos-infostring),
296                                 keylength + 1 + valuelength, keypos);
297                         if (sub_item) 
298                                 sub_tree =
299                                         proto_item_add_subtree(
300                                         sub_item,
301                                         ett_key_value);
302                         *(keyvaluesep) = 0;
303                         if (sub_tree) {
304                                 proto_tree_add_string(sub_tree,
305                                         hf_key,
306                                         tvb,
307                                         offset + (keypos-infostring),
308                                         keylength, keypos);
309                                 proto_tree_add_string(sub_tree,
310                                         hf_value,
311                                         tvb,
312                                         offset + (valuepos-infostring),
313                                         valuelength, valuepos);
314                         }
315                 }
316                 newpos = valueend + 1;
317         }
318 }
319
320
321 static const value_string names_direction[] = {
322 #define DIR_C2S 0
323         { DIR_C2S, "Client to Server" },
324 #define DIR_S2C 1
325         { DIR_S2C, "Server to Client" },
326         { 0, NULL }
327 };
328
329
330 /* I took this name and value directly out of the QW source. */
331 #define PORT_MASTER 27500
332 static unsigned int gbl_quakeworldServerPort=PORT_MASTER;
333
334
335 /* out of band message id bytes (taken out of quakeworldsource/client/protocol.h */
336  
337 /* M = master, S = server, C = client, A = any */
338 /* the second character will allways be \n if the message isn't a single */
339 /* byte long (?? not true anymore?) */
340  
341 #define S2C_CHALLENGE           'c'
342 #define S2C_CONNECTION          'j'
343 #define A2A_PING                'k'     /* respond with an A2A_ACK */
344 #define A2A_ACK                 'l'     /* general acknowledgement without info */
345 #define A2A_NACK                'm'     /* [+ comment] general failure */
346 #define A2A_ECHO                'e'     /* for echoing */
347 #define A2C_PRINT               'n'     /* print a message on client */
348  
349 #define S2M_HEARTBEAT           'a'     /* + serverinfo + userlist + fraglist */
350 #define A2C_CLIENT_COMMAND      'B'     /* + command line */
351 #define S2M_SHUTDOWN            'C'
352
353
354 static void
355 dissect_quakeworld_ConnectionlessPacket(tvbuff_t *tvb, packet_info *pinfo,
356         proto_tree *tree, int direction)
357 {
358         proto_tree      *cl_tree = NULL;
359         proto_item      *cl_item = NULL;
360         proto_item      *text_item = NULL;
361         proto_tree      *text_tree = NULL;
362         guint8          text[MAX_TEXT_SIZE+1];
363         int             maxbufsize = 0;
364         int             len;
365         int             offset;
366         guint32 marker;
367         int command_len;
368         char command[MAX_TEXT_SIZE+1];
369         int command_finished = FALSE;
370
371         marker = tvb_get_ntohl(tvb, 0);
372         if (tree) {
373                 cl_item = proto_tree_add_text(tree, tvb,
374                                 0, -1, "Connectionless");
375                 if (cl_item)
376                         cl_tree = proto_item_add_subtree(
377                                 cl_item, ett_quakeworld_connectionless);
378         }
379
380         if (cl_tree) {
381                 proto_tree_add_uint(cl_tree, hf_quakeworld_connectionless_marker,
382                                 tvb, 0, 4, marker);
383         }
384
385         /* all the rest of the packet is just text */
386         offset = 4;
387
388         maxbufsize = MIN((gint)MAX_TEXT_SIZE, tvb_length_remaining(tvb, offset));
389         len = tvb_get_nstringz0(tvb, offset, maxbufsize, text);
390         /* actually, we should look for a eol char and stop already there */
391
392         if (cl_tree) {
393                 text_item = proto_tree_add_string(cl_tree, hf_quakeworld_connectionless_text,
394                         tvb, offset, len + 1, text);
395                 if (text_item) {
396                         text_tree = proto_item_add_subtree(
397                                 text_item, ett_quakeworld_connectionless_text);
398                 }
399         }
400
401         if (direction == DIR_C2S) {
402                 /* client to sever commands */
403                 char *c;
404
405                 Cmd_TokenizeString(text);
406                 c = Cmd_Argv(0);
407                 
408                 /* client to sever commands */
409                 if (strcmp(c,"ping") == 0) {
410                         strcpy(command, "Ping");
411                         command_len = 4;
412                 } else if (strcmp(c,"status") == 0) {
413                         strcpy(command, "Status");
414                         command_len = 6;
415                 } else if (strcmp(c,"log") == 0) {
416                         strcpy(command, "Status");
417                         command_len = 3;
418                 } else if (strcmp(c,"connect") == 0) {
419                         int version;
420                         int qport;
421                         int challenge;
422                         char *infostring;
423                         proto_item *argument_item = NULL;
424                         proto_tree *argument_tree = NULL;
425                         proto_item *info_item = NULL;
426                         proto_tree *info_tree = NULL;
427                         strcpy(command, "Connect");
428                         command_len = Cmd_Argv_length(0);
429                         if (text_tree) {
430                                 proto_tree_add_string(text_tree, hf_quakeworld_connectionless_command,
431                                         tvb, offset, command_len, command);
432                                 argument_item = proto_tree_add_string(text_tree,
433                                         hf_quakeworld_connectionless_arguments,
434                                         tvb, offset + Cmd_Argv_start(1), len + 1 - Cmd_Argv_start(1), 
435                                         text + Cmd_Argv_start(1));
436                                 if (argument_item) {
437                                         argument_tree =
438                                                 proto_item_add_subtree(argument_item,   
439                                                         ett_quakeworld_connectionless_arguments);
440                                 }
441                                 command_finished=TRUE;
442                         }
443                         version = atoi(Cmd_Argv(1));
444                         qport = atoi(Cmd_Argv(2));
445                         challenge = atoi(Cmd_Argv(3));
446                         infostring = Cmd_Argv(4);
447                         if (argument_tree) {
448                                 proto_tree_add_uint(argument_tree,
449                                         hf_quakeworld_connectionless_connect_version,
450                                         tvb,
451                                         offset + Cmd_Argv_start(1),
452                                         Cmd_Argv_length(1), version);
453                                 proto_tree_add_uint(argument_tree,
454                                         hf_quakeworld_connectionless_connect_qport,
455                                         tvb,
456                                         offset + Cmd_Argv_start(2),
457                                         Cmd_Argv_length(2), qport);
458                                 proto_tree_add_int(argument_tree,
459                                         hf_quakeworld_connectionless_connect_challenge,
460                                         tvb,
461                                         offset + Cmd_Argv_start(3),
462                                         Cmd_Argv_length(3), challenge);
463                                 info_item = proto_tree_add_string(argument_tree,
464                                         hf_quakeworld_connectionless_connect_infostring,
465                                         tvb,
466                                         offset + Cmd_Argv_start(4),
467                                         Cmd_Argv_length(4), infostring);
468                                 if (info_item)
469                                         info_tree = proto_item_add_subtree(
470                                                 info_item, ett_quakeworld_connectionless_connect_infostring);
471                                 dissect_id_infostring(tvb, info_tree, offset + Cmd_Argv_start(4),
472                                         infostring,
473                                         ett_quakeworld_connectionless_connect_infostring_key_value,
474                                         hf_quakeworld_connectionless_connect_infostring_key_value,
475                                         hf_quakeworld_connectionless_connect_infostring_key,
476                                         hf_quakeworld_connectionless_connect_infostring_value);
477                         }
478                 } else if (strcmp(c,"getchallenge") == 0) {
479                         strcpy(command, "Get Challenge");
480                         command_len = Cmd_Argv_length(0);
481                 } else if (strcmp(c,"rcon") == 0) {
482                         char* password;
483                         int i;
484                         char remaining[MAX_TEXT_SIZE+1];
485                         proto_item *argument_item = NULL;
486                         proto_tree *argument_tree = NULL;
487                         strcpy(command, "Remote Command");
488                         command_len = Cmd_Argv_length(0);
489                         if (text_tree) {
490                                 proto_tree_add_string(text_tree, hf_quakeworld_connectionless_command,
491                                         tvb, offset, command_len, command);
492                                 argument_item = proto_tree_add_string(text_tree,
493                                         hf_quakeworld_connectionless_arguments,
494                                         tvb, offset + Cmd_Argv_start(1), len + 1 - Cmd_Argv_start(1), 
495                                         text + Cmd_Argv_start(1));
496                                 if (argument_item) {
497                                         argument_tree =
498                                                 proto_item_add_subtree(argument_item,   
499                                                         ett_quakeworld_connectionless_arguments);
500                                 }
501                                 command_finished=TRUE;
502                         }
503                         password = Cmd_Argv(1);
504                         if (argument_tree) {
505                                 proto_tree_add_string(argument_tree,
506                                         hf_quakeworld_connectionless_rcon_password,
507                                         tvb,
508                                         offset + Cmd_Argv_start(1),
509                                         Cmd_Argv_length(1), password);
510                         }
511                         for (i=2; i<Cmd_Argc() ; i++) {
512                                 remaining[0] = 0;
513                                 strcat (remaining, Cmd_Argv(i) );
514                                 strcat (remaining, " ");
515                         }
516                         if (text_tree) {
517                                 proto_tree_add_string(argument_tree,
518                                         hf_quakeworld_connectionless_rcon_command,
519                                         tvb, offset + Cmd_Argv_start(2),
520                                         Cmd_Argv_start(Cmd_Argc()-1) + Cmd_Argv_length(Cmd_Argc()-1) -
521                                         Cmd_Argv_start(2),
522                                         remaining);
523                         }
524                 } else if (c[0]==A2A_PING && ( c[1]==0 || c[1]=='\n')) {
525                         strcpy(command, "Ping");
526                         command_len = 1;
527                 } else if (c[0]==A2A_ACK && ( c[1]==0 || c[1]=='\n')) {
528                         strcpy(command, "Ack");
529                         command_len = 1;
530                 } else {
531                         strcpy(command, "Unknown");
532                         command_len = len;
533                 }
534         }
535         else {
536                 /* server to client commands */
537                 if (text[0] == S2C_CONNECTION) {
538                         strcpy(command, "Connected");
539                         command_len = 1;
540                 } else if (text[0] == A2C_CLIENT_COMMAND) {
541                         strcpy(command, "Client Command");
542                         command_len = 1;
543                         /* stringz (command), stringz (localid) */
544                 } else if (text[0] == A2C_PRINT) {
545                         strcpy(command, "Print");
546                         command_len = 1;
547                         /* string */
548                 } else if (text[0] == A2A_PING) {
549                         strcpy(command, "Ping");
550                         command_len = 1;
551                 } else if (text[0] == S2C_CHALLENGE) {
552                         strcpy(command, "Challenge");
553                         command_len = 1;
554                         /* string, atoi */
555                 } else {
556                         strcpy(command, "Unknown");
557                         command_len = len;
558                 }
559         }
560                 
561         if (check_col(pinfo->cinfo, COL_INFO)) {
562                 col_append_fstr(pinfo->cinfo, COL_INFO, " %s", command);
563         }
564                 
565         if (text_tree && !command_finished) {
566                 proto_tree_add_string(text_tree, hf_quakeworld_connectionless_command,
567                         tvb, offset, command_len, command);
568         }
569         offset += len + 1;
570 }
571
572
573 static void
574 dissect_quakeworld_client_commands(tvbuff_t *tvb, packet_info *pinfo,
575         proto_tree *tree)
576 {
577         /* If I have too much time at hand, I'll fill it with all
578            the information from my QWD specs:
579                 http://www.planetquake.com/demospecs/qwd/
580         */
581         call_dissector(data_handle,tvb, pinfo, tree);
582 }
583
584
585 static void
586 dissect_quakeworld_server_commands(tvbuff_t *tvb, packet_info *pinfo,
587         proto_tree *tree)
588 {
589         /* If I have too much time at hand, I'll fill it with all
590            the information from my QWD specs:
591                 http://www.planetquake.com/demospecs/qwd/
592         */
593         call_dissector(data_handle,tvb, pinfo, tree);
594 }
595
596
597 static const value_string names_reliable[] = {
598         { 0, "Non Reliable" },
599         { 1, "Reliable" },
600         { 0, NULL }
601 };
602
603
604 static void
605 dissect_quakeworld_GamePacket(tvbuff_t *tvb, packet_info *pinfo,
606         proto_tree *tree, int direction)
607 {
608         proto_tree      *game_tree = NULL;
609         proto_item      *game_item = NULL;
610         guint32 seq1;
611         guint32 seq2;
612         int rel1;
613         int rel2;
614         int offset;
615         guint           rest_length;
616
617         direction = (pinfo->destport == gbl_quakeworldServerPort) ?
618                         DIR_C2S : DIR_S2C;
619
620         if (tree) {
621                 game_item = proto_tree_add_text(tree, tvb,
622                                 0, -1, "Game");
623                 if (game_item)
624                         game_tree = proto_item_add_subtree(
625                                 game_item, ett_quakeworld_game);
626         }
627
628         offset = 0;
629
630         seq1 = tvb_get_letohl(tvb, offset);
631         rel1 = seq1 & 0x80000000 ? 1 : 0;
632         seq1 &= ~0x80000000;
633         if (game_tree) {
634                 proto_item *seq1_item = proto_tree_add_text(game_tree,
635                         tvb, offset, 4, "Current Sequence: %u (%s)",
636                         seq1, val_to_str(rel1,names_reliable,"%u"));
637                 if (seq1_item) {
638                         proto_tree *seq1_tree = proto_item_add_subtree(
639                                 seq1_item, ett_quakeworld_game_seq1);
640                         proto_tree_add_uint(seq1_tree, hf_quakeworld_game_seq1,
641                                         tvb, offset, 4, seq1);
642                         proto_tree_add_boolean(seq1_tree, hf_quakeworld_game_rel1,
643                                         tvb, offset+3, 1, rel1);
644                 }
645         }
646         offset += 4;
647
648         seq2 = tvb_get_letohl(tvb, offset);
649         rel2 = seq2 & 0x80000000 ? 1 : 0;
650         seq2 &= ~0x80000000;
651         if (game_tree) {
652                 proto_item *seq2_item = proto_tree_add_text(game_tree,
653                         tvb, offset, 4, "Acknowledge Sequence: %u (%s)",
654                         seq2, val_to_str(rel2,names_reliable,"%u"));;
655                 if (seq2_item) {
656                         proto_tree *seq2_tree = proto_item_add_subtree(
657                                 seq2_item, ett_quakeworld_game_seq2);
658                         proto_tree_add_uint(seq2_tree, hf_quakeworld_game_seq2,
659                                         tvb, offset, 4, seq2);
660                         proto_tree_add_boolean(seq2_tree, hf_quakeworld_game_rel2,
661                                         tvb, offset+3, 1, rel2);
662                 }
663         }
664         offset += 4;
665
666         if (direction == DIR_C2S) {
667                 /* client to server */
668                 guint16 qport = tvb_get_letohs(tvb, offset);
669                 if (game_tree) {
670                         proto_tree_add_uint(game_tree, hf_quakeworld_game_qport, 
671                                 tvb, offset, 2, qport);
672                 }
673                 offset +=2;
674         }
675
676         /* all the rest is pure game data */
677         rest_length = tvb_reported_length(tvb) - offset;
678         if (rest_length) {
679                 tvbuff_t *next_tvb =
680                 tvb_new_subset(tvb, offset, rest_length , rest_length);
681
682                 if (direction == DIR_C2S) {
683                         proto_item *c_item = NULL;
684                         proto_tree *c_tree = NULL;
685                         if (tree) {
686                                 c_item = proto_tree_add_text(game_tree, next_tvb,
687                                 0, -1, "Client Commands");
688                                 if (c_item) {
689                                         c_tree = proto_item_add_subtree(
690                                                 c_item, ett_quakeworld_game_clc);
691                                 }
692                         }
693                         dissect_quakeworld_client_commands(next_tvb, pinfo, c_tree);
694                 }
695                 else {
696                         proto_item *c_item = NULL;
697                         proto_tree *c_tree = NULL;
698                         if (tree) {
699                                 c_item = proto_tree_add_text(game_tree, next_tvb,
700                                 0, -1, "Server Commands");
701                                 if (c_item) {
702                                         c_tree = proto_item_add_subtree(
703                                         c_item, ett_quakeworld_game_svc);
704                                 }
705                         }
706                         dissect_quakeworld_server_commands(next_tvb, pinfo, c_tree);
707                 }
708         }
709 }
710
711
712 static void
713 dissect_quakeworld(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
714 {
715         proto_tree      *quakeworld_tree = NULL;
716         proto_item      *quakeworld_item = NULL;
717         int             direction;
718
719         direction = (pinfo->destport == gbl_quakeworldServerPort) ?
720                         DIR_C2S : DIR_S2C;
721
722         if (check_col(pinfo->cinfo, COL_PROTOCOL))
723                 col_set_str(pinfo->cinfo, COL_PROTOCOL, "QUAKEWORLD");
724         if (check_col(pinfo->cinfo, COL_INFO))
725                 col_set_str(pinfo->cinfo, COL_INFO, val_to_str(direction,
726                         names_direction, "%u"));
727
728         if (tree) {
729                 quakeworld_item = proto_tree_add_item(tree, proto_quakeworld,
730                                 tvb, 0, -1, FALSE);
731                 if (quakeworld_item)
732                         quakeworld_tree = proto_item_add_subtree(
733                                 quakeworld_item, ett_quakeworld);
734                         if (quakeworld_tree) {
735                                 proto_tree_add_uint_format(quakeworld_tree,
736                                         direction == DIR_S2C ?
737                                         hf_quakeworld_s2c :
738                                         hf_quakeworld_c2s,
739                                         tvb, 0, 0, 1,
740                                         "Direction: %s", val_to_str(direction, names_direction, "%u"));
741                         }
742         }
743
744         if (tvb_get_ntohl(tvb, 0) == 0xffffffff) {
745                 if (check_col(pinfo->cinfo, COL_INFO)) {
746                         col_append_str(pinfo->cinfo, COL_INFO, " Connectionless");
747                 }
748                 if (quakeworld_tree)
749                         proto_tree_add_uint_format(quakeworld_tree,
750                                 hf_quakeworld_connectionless,
751                                 tvb, 0, 0, 1,
752                                 "Type: Connectionless");
753                 dissect_quakeworld_ConnectionlessPacket(
754                         tvb, pinfo, quakeworld_tree, direction);
755         }
756         else {
757                 if (check_col(pinfo->cinfo, COL_INFO)) {
758                         col_append_str(pinfo->cinfo, COL_INFO, " Game");
759                 }
760                 if (quakeworld_tree)
761                         proto_tree_add_uint_format(quakeworld_tree,
762                                 hf_quakeworld_game,
763                                 tvb, 0, 0, 1,
764                                 "Type: Game");
765                 dissect_quakeworld_GamePacket(
766                         tvb, pinfo, quakeworld_tree, direction);
767         }
768 }
769
770
771 void
772 proto_reg_handoff_quakeworld(void)
773 {
774         static int Initialized=FALSE;
775         static dissector_handle_t quakeworld_handle;
776         static int ServerPort=0;
777  
778         if (!Initialized) {
779                 quakeworld_handle = create_dissector_handle(dissect_quakeworld,
780                                 proto_quakeworld);
781                 Initialized=TRUE;
782         } else {
783                 dissector_delete("udp.port", ServerPort, quakeworld_handle);
784         }
785  
786         /* set port for future deletes */
787         ServerPort=gbl_quakeworldServerPort;
788  
789         dissector_add("udp.port", gbl_quakeworldServerPort, quakeworld_handle);
790         data_handle = find_dissector("data");
791 }
792
793
794 void
795 proto_register_quakeworld(void)
796 {
797         static hf_register_info hf[] = {
798                 { &hf_quakeworld_c2s,
799                         { "Client to Server", "quakeworld.c2s",
800                         FT_UINT32, BASE_DEC, NULL, 0x0,
801                         "Client to Server", HFILL }},
802                 { &hf_quakeworld_s2c,
803                         { "Server to Client", "quakeworld.s2c",
804                         FT_UINT32, BASE_DEC, NULL, 0x0,
805                         "Server to Client", HFILL }},
806                 { &hf_quakeworld_connectionless,
807                         { "Connectionless", "quakeworld.connectionless",
808                         FT_UINT32, BASE_DEC, NULL, 0x0,
809                         "Connectionless", HFILL }},
810                 { &hf_quakeworld_game,
811                         { "Game", "quakeworld.game",
812                         FT_UINT32, BASE_DEC, NULL, 0x0,
813                         "Game", HFILL }},
814                 { &hf_quakeworld_connectionless_marker,
815                         { "Marker", "quakeworld.connectionless.marker",
816                         FT_UINT32, BASE_HEX, NULL, 0x0,
817                         "Marker", HFILL }},
818                 { &hf_quakeworld_connectionless_text,
819                         { "Text", "quakeworld.connectionless.text",
820                         FT_STRING, BASE_DEC, NULL, 0x0,
821                         "Text", HFILL }},
822                 { &hf_quakeworld_connectionless_command,
823                         { "Command", "quakeworld.connectionless.command",
824                         FT_STRING, BASE_DEC, NULL, 0x0,
825                         "Command", HFILL }},
826                 { &hf_quakeworld_connectionless_arguments,
827                         { "Arguments", "quakeworld.connectionless.arguments",
828                         FT_STRING, BASE_DEC, NULL, 0x0,
829                         "Arguments", HFILL }},
830                 { &hf_quakeworld_connectionless_connect_version,
831                         { "Version", "quakeworld.connectionless.connect.version",
832                         FT_UINT32, BASE_DEC, NULL, 0x0,
833                         "Protocol Version", HFILL }},
834                 { &hf_quakeworld_connectionless_connect_qport,
835                         { "QPort", "quakeworld.connectionless.connect.qport",
836                         FT_UINT32, BASE_DEC, NULL, 0x0,
837                         "QPort of the client", HFILL }},
838                 { &hf_quakeworld_connectionless_connect_challenge,
839                         { "Challenge", "quakeworld.connectionless.connect.challenge",
840                         FT_INT32, BASE_DEC, NULL, 0x0,
841                         "Challenge from the server", HFILL }},
842                 { &hf_quakeworld_connectionless_connect_infostring,
843                         { "Infostring", "quakeworld.connectionless.connect.infostring",
844                         FT_STRING, BASE_DEC, NULL, 0x0,
845                         "Infostring with additional variables", HFILL }},
846                 { &hf_quakeworld_connectionless_connect_infostring_key_value,
847                         { "Key/Value", "quakeworld.connectionless.connect.infostring.key_value",
848                         FT_STRING, BASE_DEC, NULL, 0x0,
849                         "Key and Value", HFILL }},
850                 { &hf_quakeworld_connectionless_connect_infostring_key,
851                         { "Key", "quakeworld.connectionless.connect.infostring.key",
852                         FT_STRING, BASE_DEC, NULL, 0x0,
853                         "Infostring Key", HFILL }},
854                 { &hf_quakeworld_connectionless_connect_infostring_value,
855                         { "Value", "quakeworld.connectionless.connect.infostring.value",
856                         FT_STRING, BASE_DEC, NULL, 0x0,
857                         "Infostring Value", HFILL }},
858                 { &hf_quakeworld_connectionless_rcon_password,
859                         { "Password", "quakeworld.connectionless.rcon.password",
860                         FT_STRING, BASE_DEC, NULL, 0x0,
861                         "Rcon Password", HFILL }},
862                 { &hf_quakeworld_connectionless_rcon_command,
863                         { "Command", "quakeworld.connectionless.rcon.command",
864                         FT_STRING, BASE_DEC, NULL, 0x0,
865                         "Command", HFILL }},
866                 { &hf_quakeworld_game_seq1,
867                         { "Sequence Number", "quakeworld.game.seq1",
868                         FT_UINT32, BASE_DEC, NULL, 0x0,
869                         "Sequence number of the current packet", HFILL }},
870                 { &hf_quakeworld_game_rel1,
871                         { "Reliable", "quakeworld.game.rel1",
872                         FT_BOOLEAN, BASE_DEC, NULL, 0x0,
873                         "Packet is reliable and may be retransmitted", HFILL }},
874                 { &hf_quakeworld_game_seq2,
875                         { "Sequence Number", "quakeworld.game.seq2",
876                         FT_UINT32, BASE_DEC, NULL, 0x0,
877                         "Sequence number of the last received packet", HFILL }},
878                 { &hf_quakeworld_game_rel2,
879                         { "Reliable", "quakeworld.game.rel2",
880                         FT_BOOLEAN, BASE_DEC, NULL, 0x0,
881                         "Packet was reliable and may be retransmitted", HFILL }},
882                 { &hf_quakeworld_game_qport,
883                         { "QPort", "quakeworld.game.qport",
884                         FT_UINT32, BASE_DEC, NULL, 0x0,
885                         "QuakeWorld Client Port", HFILL }}
886         };
887         static gint *ett[] = {
888                 &ett_quakeworld,
889                 &ett_quakeworld_connectionless,
890                 &ett_quakeworld_connectionless_text,
891                 &ett_quakeworld_connectionless_arguments,
892                 &ett_quakeworld_connectionless_connect_infostring,
893                 &ett_quakeworld_connectionless_connect_infostring_key_value,
894                 &ett_quakeworld_game,
895                 &ett_quakeworld_game_seq1,
896                 &ett_quakeworld_game_seq2,
897                 &ett_quakeworld_game_clc,
898                 &ett_quakeworld_game_svc
899         };
900         module_t *quakeworld_module;
901
902         proto_quakeworld = proto_register_protocol("QuakeWorld Network Protocol",
903                                                 "QUAKEWORLD", "quakeworld");
904         proto_register_field_array(proto_quakeworld, hf, array_length(hf));
905         proto_register_subtree_array(ett, array_length(ett));
906
907         /* Register a configuration option for port */
908         quakeworld_module = prefs_register_protocol(proto_quakeworld,
909                 proto_reg_handoff_quakeworld);
910         prefs_register_uint_preference(quakeworld_module, "udp.port",
911                                         "QuakeWorld Server UDP Port",
912                                         "Set the UDP port for the QuakeWorld Server",
913                                         10, &gbl_quakeworldServerPort);
914 }
915