/[LeafOK_CVS]/pvpgn-1.7.4/src/common/packet.c
ViewVC logotype

Annotation of /pvpgn-1.7.4/src/common/packet.c

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.1 - (hide annotations)
Tue Jun 6 03:41:38 2006 UTC (19 years, 9 months ago) by sysadm
CVS Tags: pvpgn_1-7-4-0_MIL
Branch point for: GNU, MAIN
Content type: text/x-csrc 
Initial revision
1 sysadm 1.1 /*
2     * Copyright (C) 1998,1999,2000 Ross Combs (rocombs@cs.nmsu.edu)
3     * Copyright (C) 1999,2000,2001 Marco Ziech (mmz@gmx.net)
4     *
5     * This program is free software; you can redistribute it and/or
6     * modify it under the terms of the GNU General Public License
7     * as published by the Free Software Foundation; either version 2
8     * of the License, or (at your option) any later version.
9     *
10     * This program is distributed in the hope that it will be useful,
11     * but WITHOUT ANY WARRANTY; without even the implied warranty of
12     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13     * GNU General Public License for more details.
14     *
15     * You should have received a copy of the GNU General Public License
16     * along with this program; if not, write to the Free Software
17     * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18     */
19     #include "common/setup_before.h"
20     #ifdef HAVE_STDDEF_H
21     # include <stddef.h>
22     #else
23     # ifndef NULL
24     # define NULL ((void *)0)
25     # endif
26     #endif
27     #ifdef STDC_HEADERS
28     # include <stdlib.h>
29     #else
30     # ifdef HAVE_MALLOC_H
31     # include <malloc.h>
32     # endif
33     #endif
34     #ifdef HAVE_STRING_H
35     # include <string.h>
36     #else
37     # ifdef HAVE_STRINGS_H
38     # include <strings.h>
39     # endif
40     #endif
41     #ifdef HAVE_MEMORY_H
42     # include <memory.h>
43     #endif
44     #include "compat/memcpy.h"
45     #include "common/eventlog.h"
46     #include "common/bn_type.h"
47     #include "common/field_sizes.h"
48     #include "common/xalloc.h"
49     #include "common/lstr.h"
50     #include "common/packet.h"
51     #include "common/setup_after.h"
52    
53    
54     extern t_packet * packet_create(t_packet_class class)
55     {
56     t_packet * temp;
57    
58     if (class!=packet_class_init &&
59     class!=packet_class_bnet &&
60     class!=packet_class_file &&
61     class!=packet_class_udp &&
62     class!=packet_class_raw &&
63     class!=packet_class_d2game &&
64     class!=packet_class_d2cs &&
65     class!=packet_class_d2gs &&
66     class!=packet_class_d2cs_bnetd &&
67     class!=packet_class_w3route)
68     {
69     eventlog(eventlog_level_error,__FUNCTION__,"invalid packet class %d",(int)class);
70     return NULL;
71     }
72    
73     temp = xmalloc(sizeof(t_packet));
74     temp->ref = 1;
75     temp->class = class;
76     temp->flags = 0;
77     packet_set_size(temp,0);
78    
79     return temp;
80     }
81    
82    
83     extern void packet_destroy(t_packet const * packet)
84     {
85     if (!packet)
86     {
87     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
88     return;
89     }
90    
91     xfree((void *)packet); /* avoid warning */
92     }
93    
94    
95     extern t_packet * packet_add_ref(t_packet * packet)
96     {
97     if (!packet)
98     {
99     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
100     return NULL;
101     }
102    
103     packet->ref++;
104     return packet;
105     }
106    
107    
108     extern void packet_del_ref(t_packet * packet)
109     {
110     if (!packet)
111     {
112     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
113     return;
114     }
115    
116     if (packet->ref<2) /* if would go to zero */
117     packet_destroy(packet);
118     else
119     packet->ref--;
120     }
121    
122    
123     extern t_packet_class packet_get_class(t_packet const * packet)
124     {
125     if (!packet)
126     {
127     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
128     return packet_class_none;
129     }
130    
131     switch (packet->class)
132     {
133     case packet_class_init:
134     return packet_class_init;
135     case packet_class_bnet:
136     return packet_class_bnet;
137     case packet_class_file:
138     return packet_class_file;
139     case packet_class_udp:
140     return packet_class_udp;
141     case packet_class_raw:
142     return packet_class_raw;
143     case packet_class_d2game:
144     return packet_class_d2game;
145     case packet_class_d2cs:
146     return packet_class_d2cs;
147     case packet_class_d2gs:
148     return packet_class_d2gs;
149     case packet_class_d2cs_bnetd:
150     return packet_class_d2cs_bnetd;
151     case packet_class_w3route:
152     return packet_class_w3route;
153     case packet_class_none:
154     return packet_class_none;
155     default:
156     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
157     return packet_class_none;
158     }
159     }
160    
161    
162     extern char const * packet_get_class_str(t_packet const * packet)
163     {
164     if (!packet)
165     {
166     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
167     return "unknown";
168     }
169    
170     switch (packet->class)
171     {
172     case packet_class_init:
173     return "init";
174     case packet_class_bnet:
175     return "bnet";
176     case packet_class_file:
177     return "file";
178     case packet_class_udp:
179     return "udp";
180     case packet_class_raw:
181     return "raw";
182     case packet_class_d2game:
183     return "d2game";
184     case packet_class_d2gs:
185     return "d2gs";
186     case packet_class_d2cs_bnetd:
187     return "d2cs_bnetd";
188     case packet_class_d2cs:
189     return "d2cs";
190     case packet_class_w3route:
191     return "w3route";
192     case packet_class_none:
193     return "none";
194     default:
195     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
196     return "unknown";
197     }
198     }
199    
200    
201     extern int packet_set_class(t_packet * packet, t_packet_class class)
202     {
203     if (!packet)
204     {
205     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
206     return -1;
207     }
208     if (packet->class!=packet_class_raw)
209     {
210     eventlog(eventlog_level_error,__FUNCTION__,"got non-raw packet");
211     return -1;
212     }
213     if (class!=packet_class_init &&
214     class!=packet_class_bnet &&
215     class!=packet_class_file &&
216     class!=packet_class_udp &&
217     class!=packet_class_raw &&
218     class!=packet_class_d2game &&
219     class!=packet_class_d2cs &&
220     class!=packet_class_d2gs &&
221     class!=packet_class_d2cs_bnetd &&
222     class!=packet_class_w3route)
223     {
224     eventlog(eventlog_level_error,__FUNCTION__,"invalid packet class %d",(int)class);
225     return -1;
226     }
227    
228     packet->class = class;
229     return 0;
230     }
231    
232    
233     extern unsigned int packet_get_type(t_packet const * packet)
234     {
235     if (!packet)
236     {
237     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
238     return 0;
239     }
240    
241     switch (packet->class)
242     {
243     case packet_class_init:
244     return CLIENT_INITCONN; /* all init packets are of this type */
245    
246     case packet_class_bnet:
247     if (packet_get_size(packet)<sizeof(t_bnet_header))
248     {
249     eventlog(eventlog_level_error,__FUNCTION__,"bnet packet is shorter than header (len=%u)",packet_get_size(packet));
250     return 0;
251     }
252     return (unsigned int)bn_short_get(packet->u.bnet.h.type);
253    
254     case packet_class_file:
255     if (packet_get_size(packet)<sizeof(t_file_header))
256     {
257     eventlog(eventlog_level_error,__FUNCTION__,"file packet is shorter than header (len=%u)",packet_get_size(packet));
258     return 0;
259     }
260     return (unsigned int)bn_short_get(packet->u.file.h.type);
261    
262     case packet_class_udp:
263     if (packet_get_size(packet)<sizeof(t_udp_header))
264     {
265     eventlog(eventlog_level_error,__FUNCTION__,"udp packet is shorter than header (len=%u)",packet_get_size(packet));
266     return 0;
267     }
268     return bn_int_get(packet->u.udp.h.type);
269    
270     case packet_class_raw:
271     return 0; /* raw packets don't have a type, but don't warn because the packet dump tries anyway */
272    
273     case packet_class_d2game:
274     if (packet_get_size(packet)<sizeof(t_d2game_header))
275     {
276     eventlog(eventlog_level_error,__FUNCTION__,"d2game packet is shorter than header (len=%u)",packet_get_size(packet));
277     return 0;
278     }
279     return bn_byte_get(packet->u.d2game.h.type);
280    
281     case packet_class_d2gs:
282     if (packet_get_size(packet)<sizeof(t_d2cs_d2gs_header))
283     {
284     eventlog(eventlog_level_error,__FUNCTION__,"d2gs packet is shorter than header (len=%u)",packet_get_size(packet));
285     return 0;
286     }
287     return bn_short_get(packet->u.d2cs_d2gs.h.type);
288     case packet_class_d2cs_bnetd:
289     if (packet_get_size(packet)<sizeof(t_d2cs_bnetd_header)) {
290     eventlog(eventlog_level_error,__FUNCTION__,"d2cs_bnetd packet shorter than header (len=%u)",packet_get_size(packet));
291     return 0;
292     }
293     return bn_short_get(packet->u.d2cs_d2gs.h.type);
294    
295     case packet_class_d2cs:
296     if (packet_get_size(packet)<sizeof(t_d2cs_client_header))
297     {
298     eventlog(eventlog_level_error,__FUNCTION__,"d2cs packet is shorter than header (len=%u)",packet_get_size(packet));
299     return 0;
300     }
301     return bn_byte_get(packet->u.d2cs_client.h.type);
302    
303     case packet_class_w3route:
304     if (packet_get_size(packet)<sizeof(t_w3route_header))
305     {
306     eventlog(eventlog_level_error,__FUNCTION__,"w3route packet is shorter than header (len=%u)",packet_get_size(packet));
307     return 0;
308     }
309     return bn_short_get(packet->u.w3route.h.type);
310    
311    
312     default:
313     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
314     return 0;
315     }
316     }
317    
318    
319     extern char const * packet_get_type_str(t_packet const * packet, t_packet_dir dir)
320     {
321     if (!packet)
322     {
323     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
324     return "unknown";
325     }
326    
327     switch (dir)
328     {
329     case packet_dir_from_client:
330     switch (packet->class)
331     {
332     case packet_class_init:
333     return "CLIENT_INITCONN";
334     case packet_class_bnet:
335     if (packet_get_size(packet)<sizeof(t_bnet_header))
336     {
337     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
338     return "unknown";
339     }
340     switch (bn_short_get(packet->u.bnet.h.type))
341     {
342     case CLIENT_COMPINFO1:
343     return "CLIENT_COMPINFO1";
344     case CLIENT_COMPINFO2:
345     return "CLIENT_COMPINFO2";
346     case CLIENT_COUNTRYINFO1:
347     return "CLIENT_COUNTRYINFO1";
348     case CLIENT_COUNTRYINFO_109:
349     return "CLIENT_COUNTRYINFO_109";
350     case CLIENT_CREATEACCTREQ1:
351     return "CLIENT_CREATEACCTREQ1";
352     case CLIENT_UNKNOWN_2B:
353     return "CLIENT_UNKNOWN_2B";
354     case CLIENT_PROGIDENT:
355     return "CLIENT_PROGIDENT";
356     case CLIENT_AUTHREQ1:
357     return "CLIENT_AUTHREQ1";
358     case CLIENT_AUTHREQ_109:
359     return "CLIENT_AUTHREQ_109";
360     case CLIENT_REGSNOOPREPLY:
361     return "CLIENT_REGSNOOPREPLY";
362     case CLIENT_ICONREQ:
363     return "CLIENT_ICONREQ";
364     case CLIENT_LADDERSEARCHREQ:
365     return "CLIENT_LADDERSEARCHREQ";
366     case CLIENT_CDKEY:
367     return "CLIENT_CDKEY";
368     case CLIENT_CDKEY2:
369     return "CLIENT_CDKEY2";
370     case CLIENT_CDKEY3:
371     return "CLIENT_CDKEY3";
372     case CLIENT_REALMLISTREQ:
373     return "CLIENT_REALMLISTREQ";
374     case CLIENT_REALMLISTREQ_110:
375     return "CLIENT_REALMLISTREQ_110";
376     case CLIENT_PROFILEREQ:
377     return "CLIENT_PROFILEREQ";
378     case CLIENT_UNKNOWN_37:
379     return "CLIENT_UNKNOWN_37";
380     case CLIENT_UNKNOWN_39:
381     return "CLIENT_UNKNOWN_39";
382     case CLIENT_LOGINREQ2:
383     return "CLIENT_LOGINREQ2";
384     case CLIENT_MOTD_W3:
385     return "CLIENT_MOTD_W3";
386     case CLIENT_LOGINREQ_W3:
387     return "CLIENT_LOGINREQ_W3";
388     case CLIENT_LOGONPROOFREQ:
389     return "CLIENT_LOGONPROOFREQ";
390     case CLIENT_CREATEACCOUNT_W3:
391     return "CLIENT_CREATEACCOUNT_W3";
392     case CLIENT_CHANGEGAMEPORT:
393     return "CLIENT_CHANGEGAMEPORT";
394     case CLIENT_CREATEACCTREQ2:
395     return "CLIENT_CREATEACCTREQ2";
396     case CLIENT_UDPOK:
397     return "CLIENT_UDPOK";
398     case CLIENT_FILEINFOREQ:
399     return "CLIENT_FILEINFOREQ";
400     case CLIENT_STATSREQ:
401     return "CLIENT_STATSREQ";
402     case CLIENT_LOGINREQ1:
403     return "CLIENT_LOGINREQ1";
404     case CLIENT_CHANGEPASSREQ:
405     return "CLIENT_CHANGEPASSREQ";
406     case CLIENT_PLAYERINFOREQ:
407     return "CLIENT_PLAYERINFOREQ";
408     case CLIENT_PROGIDENT2:
409     return "CLIENT_PROGIDENT2";
410     case CLIENT_JOINCHANNEL:
411     return "CLIENT_JOINCHANNEL";
412     case CLIENT_MESSAGE:
413     return "CLIENT_MESSAGE";
414     case CLIENT_GAMELISTREQ:
415     return "CLIENT_GAMELISTREQ";
416     case CLIENT_STARTGAME1:
417     return "CLIENT_STARTGAME1";
418     case CLIENT_UNKNOWN_1B:
419     return "CLIENT_UNKNOWN_1B";
420     case CLIENT_STARTGAME3:
421     return "CLIENT_STARTGAME3";
422     case CLIENT_STARTGAME4:
423     return "CLIENT_STARTGAME4";
424     case CLIENT_CLOSEGAME:
425     return "CLIENT_CLOSEGAME";
426     case CLIENT_CLOSEGAME2:
427     return "CLIENT_CLOSEGAME2";
428     case CLIENT_LEAVECHANNEL:
429     return "CLIENT_LEAVECHANNEL";
430     case CLIENT_MAPAUTHREQ1:
431     return "CLIENT_MAPAUTHREQ1";
432     case CLIENT_MAPAUTHREQ2:
433     return "CLIENT_MAPAUTHREQ2";
434     case CLIENT_ADREQ:
435     return "CLIENT_ADREQ";
436     case CLIENT_ADACK:
437     return "CLIENT_ADACK";
438     case CLIENT_ADCLICK:
439     return "CLIENT_ADCLICK";
440     case CLIENT_ADCLICK2:
441     return "CLIENT_ADCLICK2";
442     case CLIENT_UNKNOWN_17:
443     return "CLIENT_UNKNOWN_17";
444     case CLIENT_UNKNOWN_24:
445     return "CLIENT_UNKNOWN_24";
446     case CLIENT_LADDERREQ:
447     return "CLIENT_LADDERREQ";
448     case CLIENT_ECHOREPLY:
449     return "CLIENT_ECHOREPLY";
450     case CLIENT_PINGREQ:
451     return "CLIENT_PINGREQ";
452     case CLIENT_GAME_REPORT:
453     return "CLIENT_GAME_REPORT";
454     case CLIENT_JOIN_GAME:
455     return "CLIENT_JOIN_GAME";
456     case CLIENT_STATSUPDATE:
457     return "CLIENT_STATSUPDATE";
458     case CLIENT_REALMJOINREQ_109:
459     return "CLIENT_REALMJOINREQ_109";
460     case CLIENT_CHANGECLIENT:
461     return "CLIENT_CHANGECLIENT";
462     case CLIENT_SETEMAILREPLY:
463     return "CLIENT_SETEMAILREPLY";
464     case CLIENT_GETPASSWORDREQ:
465     return "CLIENT_GETPASSWORDREQ";
466     case CLIENT_CHANGEEMAILREQ:
467     return "CLIENT_CHANGEEMAILREQ";
468     case CLIENT_CRASHDUMP:
469     return "CLIENT_CRASHDUMP";
470     case CLIENT_FINDANONGAME:
471     return "CLIENT_FINDANONGAME";
472     case CLIENT_ARRANGEDTEAM_FRIENDSCREEN:
473     return "CLIENT_ARRANGEDTEAM_FRIENDSCREEN";
474     case CLIENT_ARRANGEDTEAM_INVITE_FRIEND:
475     return "CLIENT_ARRANGEDTEAM_INVITE_FRIEND";
476     case CLIENT_ARRANGEDTEAM_ACCEPT_DECLINE_INVITE:
477     return "CLIENT_ARRANGEDTEAM_ACCEPT_DECLINE_INVITE";
478     case CLIENT_FRIENDSLISTREQ:
479     return "CLIENT_FRIENDSLISTREQ";
480     case CLIENT_FRIENDINFOREQ:
481     return "CLIENT_FRIENDINFOREQ";
482     case CLIENT_CLANINFOREQ:
483     return "CLIENT_CLANINFOREQ";
484     }
485     return "unknown";
486    
487     case packet_class_file:
488     if (packet_get_size(packet)<sizeof(t_file_header))
489     {
490     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
491     return "unknown";
492     }
493     switch (bn_short_get(packet->u.file.h.type))
494     {
495     case CLIENT_FILE_REQ:
496     return "CLIENT_FILE_REQ";
497     }
498     return "unknown";
499    
500     case packet_class_udp:
501     if (packet_get_size(packet)<sizeof(t_udp_header))
502     {
503     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
504     return "unknown";
505     }
506     switch (bn_int_get(packet->u.udp.h.type))
507     {
508     case SERVER_UDPTEST: /* we get these if we send stuff to ourself */
509     return "SERVER_UDPTEST";
510     case CLIENT_UDPPING:
511     return "CLIENT_UDPPING";
512     case CLIENT_SESSIONADDR1:
513     return "CLIENT_SESSIONADDR1";
514     case CLIENT_SESSIONADDR2:
515     return "CLIENT_SESSIONADDR2";
516     }
517     return "unknown";
518    
519     case packet_class_raw:
520     return "CLIENT_RAW";
521    
522     case packet_class_d2game:
523     if (packet_get_size(packet)<sizeof(t_d2game_header))
524     {
525     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
526     return "unknown";
527     }
528     switch (bn_byte_get(packet->u.d2game.h.type))
529     {
530     default:
531     return "CLIENT_D2GAME";
532     }
533     return "unknown";
534    
535     case packet_class_d2cs:
536     return "D2CS";
537     case packet_class_d2gs:
538     return "D2GS";
539     case packet_class_d2cs_bnetd:
540     return "D2CS_BNETD";
541    
542     case packet_class_w3route:
543     if (packet_get_size(packet)<sizeof(t_w3route_header))
544     {
545     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
546     return "unknown";
547     }
548     switch (bn_short_get(packet->u.bnet.h.type))
549     {
550     case CLIENT_W3ROUTE_REQ:
551     return "CLIENT_W3ROUTE_REQ";
552     case CLIENT_W3ROUTE_LOADINGDONE:
553     return "CLIENT_W3ROUTE_LOADINGDONE";
554     case CLIENT_W3ROUTE_ABORT:
555     return "CLIENT_W3ROUTE_ABORT";
556     case CLIENT_W3ROUTE_CONNECTED:
557     return "CLIENT_W3ROUTE_CONNECTED";
558     case CLIENT_W3ROUTE_ECHOREPLY:
559     return "CLIENT_W3ROUTE_ECHOREPLY";
560     case CLIENT_W3ROUTE_GAMERESULT:
561     return "CLIENT_W3ROUTE_GAMERESULT";
562     case CLIENT_W3ROUTE_GAMERESULT_W3XP:
563     return "CLIENT_W3ROUTE_GAMERESULT_W3XP";
564     }
565     return "unknown";
566    
567     case packet_class_none:
568     return "unknown";
569     }
570    
571     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
572     return "unknown";
573    
574     case packet_dir_from_server:
575     switch (packet->class)
576     {
577     case packet_class_init:
578     return "unknown";
579     case packet_class_bnet:
580     if (packet_get_size(packet)<sizeof(t_bnet_header))
581     {
582     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
583     return "unknown";
584     }
585     switch (bn_short_get(packet->u.bnet.h.type))
586     {
587     case SERVER_COMPREPLY:
588     return "SERVER_COMPREPLY";
589     case SERVER_SESSIONKEY1:
590     return "SERVER_SESSIONKEY1";
591     case SERVER_SESSIONKEY2:
592     return "SERVER_SESSIONKEY2";
593     case SERVER_CREATEACCTREPLY1:
594     return "SERVER_CREATEACCTREPLY1";
595     case SERVER_AUTHREQ1:
596     return "SERVER_AUTHREQ1";
597     case SERVER_AUTHREQ_109:
598     return "SERVER_AUTHREQ_109";
599     case SERVER_AUTHREPLY1:
600     return "SERVER_AUTHREPLY1";
601     case SERVER_AUTHREPLY_109:
602     return "SERVER_AUTHREPLY_109";
603     case SERVER_REGSNOOPREQ:
604     return "SERVER_REGSNOOPREQ";
605     case SERVER_ICONREPLY:
606     return "SERVER_ICONREPLY";
607     case SERVER_LADDERSEARCHREPLY:
608     return "SERVER_LADDERSEARCHREPLY";
609     case SERVER_CDKEYREPLY:
610     return "SERVER_CDKEYREPLY";
611     case SERVER_CDKEYREPLY2:
612     return "SERVER_CDKEYREPLY2";
613     case SERVER_CDKEYREPLY3:
614     return "SERVER_CDKEYREPLY3";
615     case SERVER_REALMLISTREPLY:
616     return "SERVER_REALMLISTREPLY";
617     case SERVER_REALMLISTREPLY_110:
618     return "SERVER_REALMLISTREPLY_110";
619     case SERVER_PROFILEREPLY:
620     return "SERVER_PROFILEREPLY";
621     case SERVER_UNKNOWN_37:
622     return "SERVER_UNKNOWN_37";
623     case SERVER_MOTD_W3:
624     return "SERVER_MOTD_W3";
625     case SERVER_LOGINREPLY_W3:
626     return "SERVER_LOGINREPLY_W3";
627     case SERVER_LOGONPROOFREPLY:
628     return "SERVER_LOGONPROOFREPLY";
629     case SERVER_CREATEACCOUNT_W3:
630     return "SERVER_CREATEACCTREPLY2";
631     case SERVER_LOGINREPLY2:
632     return "SERVER_LOGINREPLY2";
633     case SERVER_CREATEACCTREPLY2:
634     return "SERVER_CREATEACCOUNT_W3";
635     case SERVER_FILEINFOREPLY:
636     return "SERVER_FILEINFOREPLY";
637     case SERVER_STATSREPLY:
638     return "SERVER_STATSREPLY";
639     case SERVER_LOGINREPLY1:
640     return "SERVER_LOGINREPLY1";
641     case SERVER_CHANGEPASSACK:
642     return "SERVER_CHANGEPASSACK";
643     case SERVER_PLAYERINFOREPLY:
644     return "SERVER_PLAYERINFOREPLY";
645     case SERVER_CHANNELLIST:
646     return "SERVER_CHANNELLIST";
647     case SERVER_SERVERLIST:
648     return "SERVER_SERVERLIST";
649     case SERVER_MESSAGE:
650     return "SERVER_MESSAGE";
651     case SERVER_GAMELISTREPLY:
652     return "SERVER_GAMELISTREPLY";
653     case SERVER_STARTGAME1_ACK:
654     return "SERVER_STARTGAME1_ACK";
655     case SERVER_STARTGAME3_ACK:
656     return "SERVER_STARTGAME3_ACK";
657     case SERVER_STARTGAME4_ACK:
658     return "SERVER_STARTGAME4_ACK";
659     case SERVER_MAPAUTHREPLY1:
660     return "SERVER_MAPAUTHREPLY1";
661     case SERVER_MAPAUTHREPLY2:
662     return "SERVER_MAPAUTHREPLY2";
663     case SERVER_ADREPLY:
664     return "SERVER_ADREPLY";
665     case SERVER_ADCLICKREPLY2:
666     return "SERVER_ADCLICKREPLY2";
667     case SERVER_LADDERREPLY:
668     return "SERVER_LADDERREPLY";
669     case SERVER_ECHOREQ:
670     return "SERVER_ECHOREQ";
671     case SERVER_PINGREPLY:
672     return "SERVER_PINGREPLY";
673     case SERVER_REALMJOINREPLY_109:
674     return "SERVER_REALMJOINREPLY_109";
675     case SERVER_SETEMAILREQ:
676     return "SERVER_SETEMAILREQ";
677     case SERVER_FINDANONGAME:
678     return "SERVER_FINDANONGAME";
679     case SERVER_ARRANGEDTEAM_FRIENDSCREEN:
680     return "SERVER_ARRANGEDTEAM_FRIENDSCREEN";
681     case SERVER_ARRANGEDTEAM_INVITE_FRIEND_ACK:
682     return "SERVER_ARRANGEDTEAM_INVITE_FRIEND_ACK";
683     case SERVER_ARRANGEDTEAM_SEND_INVITE:
684     return "SERVER_ARRANGEDTEAM_SEND_INVITE";
685     case SERVER_ARRANGEDTEAM_MEMBER_DECLINE:
686     return "SERVER_ARRANGEDTEAM_MEMBER_DECLINE";
687     case SERVER_FRIENDSLISTREPLY:
688     return "SERVER_FRIENDSLISTREPLY";
689     case SERVER_FRIENDINFOREPLY:
690     return "SERVER_FRIENDINFOREPLY";
691     case SERVER_FRIENDADD_ACK:
692     return "SERVER_FRIENDADD_ACK";
693     case SERVER_FRIENDDEL_ACK:
694     return "SERVER_FRIENDDEL_ACK";
695     case SERVER_FRIENDMOVE_ACK:
696     return "SERVER_FRIENDMOVE_ACK";
697     case SERVER_CLANINFOREPLY:
698     return "SERVER_CLANINFO_REPLY";
699     }
700     return "unknown";
701    
702     case packet_class_file:
703     if (packet_get_size(packet)<sizeof(t_file_header))
704     {
705     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
706     return "unknown";
707     }
708     switch (bn_short_get(packet->u.file.h.type))
709     {
710     case SERVER_FILE_REPLY:
711     return "SERVER_FILE_REPLY";
712     }
713     return "unknown";
714    
715     case packet_class_udp:
716     if (packet_get_size(packet)<sizeof(t_udp_header))
717     {
718     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
719     return "unknown";
720     }
721     switch (bn_int_get(packet->u.udp.h.type))
722     {
723     case SERVER_UDPTEST:
724     return "SERVER_UDPTEST";
725     }
726     return "unknown";
727    
728     case packet_class_raw:
729     return "SERVER_RAW";
730    
731     case packet_class_d2game:
732     if (packet_get_size(packet)<sizeof(t_d2game_header))
733     {
734     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
735     return "unknown";
736     }
737     switch (bn_byte_get(packet->u.d2game.h.type))
738     {
739     default:
740     return "SERVER_D2GAME";
741     }
742     return "unknown";
743    
744     case packet_class_d2cs:
745     return "D2CS";
746     case packet_class_d2gs:
747     return "D2GS";
748     case packet_class_d2cs_bnetd:
749     return "D2CS_BNETD";
750    
751     case packet_class_w3route:
752     if (packet_get_size(packet)<sizeof(t_w3route_header))
753     {
754     eventlog(eventlog_level_error,__FUNCTION__,"packet is shorter than header (len=%u)",packet_get_size(packet));
755     return "unknown";
756     }
757     switch (bn_short_get(packet->u.bnet.h.type))
758     {
759     case SERVER_W3ROUTE_READY:
760     return "SERVER_W3ROUTE_READY";
761     case SERVER_W3ROUTE_LOADINGACK:
762     return "SERVER_W3ROUTE_LOADINGACK";
763     case SERVER_W3ROUTE_ECHOREQ:
764     return "SERVER_W3ROUTE_ECHOREQ";
765     case SERVER_W3ROUTE_ACK:
766     return "SERVER_W3ROUTE_ACK";
767     case SERVER_W3ROUTE_PLAYERINFO:
768     return "SERVER_W3ROUTE_PLAYERINFO";
769     case SERVER_W3ROUTE_LEVELINFO:
770     return "SERVER_W3ROUTE_LEVELINFO";
771     case SERVER_W3ROUTE_STARTGAME1:
772     return "SERVER_W3ROUTE_STARTGAME1";
773     case SERVER_W3ROUTE_STARTGAME2:
774     return "SERVER_W3ROUTE_STARTGAME2";
775     }
776     return "unknown";
777     case packet_class_none:
778     return "unknown";
779     }
780    
781     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
782     return "unknown";
783     }
784    
785     eventlog(eventlog_level_error,__FUNCTION__,"got unknown direction %d",(int)dir);
786     return "unknown";
787     }
788    
789    
790     extern int packet_set_type(t_packet * packet, unsigned int type)
791     {
792     if (!packet)
793     {
794     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
795     return -1;
796     }
797    
798     switch (packet->class)
799     {
800     case packet_class_init:
801     if (type!=CLIENT_INITCONN)
802     {
803     eventlog(eventlog_level_error,__FUNCTION__,"init packet type 0x%08x is not valid",type);
804     return -1;
805     }
806     return 0;
807    
808     case packet_class_bnet:
809     if (packet_get_size(packet)<sizeof(t_bnet_header))
810     {
811     eventlog(eventlog_level_error,__FUNCTION__,"bnet packet is shorter than header (len=%u)",packet_get_size(packet));
812     return -1;
813     }
814     if (type>MAX_NORMAL_TYPE)
815     {
816     eventlog(eventlog_level_error,__FUNCTION__,"bnet packet type 0x%08x is too large",type);
817     return -1;
818     }
819     bn_short_set(&packet->u.bnet.h.type,(unsigned short)type);
820     return 0;
821    
822     case packet_class_file:
823     if (packet_get_size(packet)<sizeof(t_file_header))
824     {
825     eventlog(eventlog_level_error,__FUNCTION__,"file packet is shorter than header (len=%u)",packet_get_size(packet));
826     return -1;
827     }
828     if (type>MAX_FILE_TYPE)
829     {
830     eventlog(eventlog_level_error,__FUNCTION__,"file packet type 0x%08x is too large",type);
831     return -1;
832     }
833     bn_short_set(&packet->u.file.h.type,(unsigned short)type);
834     return 0;
835    
836     case packet_class_udp:
837     if (packet_get_size(packet)<sizeof(t_udp_header))
838     {
839     eventlog(eventlog_level_error,__FUNCTION__,"udp packet is shorter than header (len=%u)",packet_get_size(packet));
840     return -1;
841     }
842     bn_int_set(&packet->u.udp.h.type,type);
843     return 0;
844    
845     case packet_class_d2game:
846     if (packet_get_size(packet)<sizeof(t_d2game_header))
847     {
848     eventlog(eventlog_level_error,__FUNCTION__,"d2game packet is shorter than header (len=%u)",packet_get_size(packet));
849     return -1;
850     }
851     bn_byte_set(&packet->u.d2game.h.type,type);
852     return 0;
853    
854     case packet_class_d2gs:
855     if (packet_get_size(packet)<sizeof(t_d2cs_d2gs_header))
856     {
857     eventlog(eventlog_level_error,__FUNCTION__,"d2gs packet is shorter than header (len=%u)",packet_get_size(packet));
858     return -1;
859     }
860     bn_short_set(&packet->u.d2cs_d2gs.h.type,type);
861     return 0;
862    
863     case packet_class_d2cs_bnetd:
864     if (packet_get_size(packet)<sizeof(t_d2cs_bnetd_header))
865     {
866     eventlog(eventlog_level_error,__FUNCTION__,"d2cs_bnetd packet is shorter than header (len=%u)",packet_get_size(packet));
867     return -1;
868     }
869     bn_short_set(&packet->u.d2cs_bnetd.h.type,type);
870     return 0;
871    
872     case packet_class_d2cs:
873     if (packet_get_size(packet)<sizeof(t_d2cs_client_header))
874     {
875     eventlog(eventlog_level_error,__FUNCTION__,"d2cs packet is shorter than header (len=%u)",packet_get_size(packet));
876     return -1;
877     }
878     bn_byte_set(&packet->u.d2cs_client.h.type,type);
879     return 0;
880    
881     case packet_class_w3route:
882     if (packet_get_size(packet)<sizeof(t_w3route_header))
883     {
884     eventlog(eventlog_level_error,__FUNCTION__,"w3route packet is shorter than header (len=%u)",packet_get_size(packet));
885     return -1;
886     }
887     bn_short_set(&packet->u.w3route.h.type,(unsigned short)type);
888     return 0;
889    
890    
891     case packet_class_raw:
892     eventlog(eventlog_level_error,__FUNCTION__,"can not set packet type for raw packet");
893     return 0;
894    
895     default:
896     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
897     return -1;
898     }
899     }
900    
901    
902     /* size of the _complete_ packet, not the amount currently received or sent */
903     extern unsigned int packet_get_size(t_packet const * packet)
904     {
905     unsigned int size;
906    
907     if (!packet)
908     {
909     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
910     return 0;
911     }
912    
913     switch (packet->class)
914     {
915     case packet_class_init:
916     size = sizeof(t_client_initconn);
917     break;
918     case packet_class_bnet:
919     size = (unsigned int)bn_short_get(packet->u.bnet.h.size);
920     break;
921     case packet_class_file:
922     size = (unsigned int)bn_short_get(packet->u.file.h.size);
923     break;
924     case packet_class_udp:
925     size = packet->len;
926     break;
927     case packet_class_raw:
928     size = packet->len;
929     break;
930     case packet_class_d2game:
931     size = packet->len; /* FIXME: does header not contain the size? */
932     break;
933     case packet_class_d2gs:
934     size = (unsigned int)bn_short_get(packet->u.d2cs_d2gs.h.size);
935     break;
936     case packet_class_d2cs_bnetd:
937     size = (unsigned int)bn_short_get(packet->u.d2cs_bnetd.h.size);
938     break;
939     case packet_class_d2cs:
940     size = (unsigned int)bn_short_get(packet->u.d2cs_client.h.size);
941     break;
942     case packet_class_w3route:
943     size = (unsigned int)bn_short_get(packet->u.w3route.h.size);
944     break;
945     default:
946     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
947     return 0;
948     }
949    
950     if (size>MAX_PACKET_SIZE)
951     {
952     eventlog(eventlog_level_error,__FUNCTION__,"packet has bad size %u",size);
953     return 0;
954     }
955     return size;
956     }
957    
958    
959     extern int packet_set_size(t_packet * packet, unsigned int size)
960     {
961     if (!packet)
962     {
963     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
964     return -1;
965     }
966     if (size>MAX_PACKET_SIZE)
967     {
968     eventlog(eventlog_level_error,__FUNCTION__,"got bad size %u",size);
969     return -1;
970     }
971    
972     switch (packet->class)
973     {
974     case packet_class_init:
975     if (size!=0 && size!=sizeof(t_client_initconn))
976     {
977     eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for init packet",size);
978     return -1;
979     }
980     packet->len = size;
981     return 0;
982     case packet_class_bnet:
983     if (size!=0 && size<sizeof(t_bnet_header))
984     {
985     eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for bnet packet",size);
986     return -1;
987     }
988     bn_short_set(&packet->u.bnet.h.size,size);
989     return 0;
990     case packet_class_file:
991     if (size!=0 && size<sizeof(t_file_header))
992     {
993     eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for file packet",size);
994     return -1;
995     }
996     bn_short_set(&packet->u.file.h.size,size);
997     return 0;
998     case packet_class_udp:
999     if (size!=0 && size<sizeof(t_udp_header))
1000     {
1001     eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for udp packet",size);
1002     return -1;
1003     }
1004     packet->len = size;
1005     return 0;
1006     case packet_class_raw:
1007     packet->len = size;
1008     return 0;
1009     case packet_class_d2game:
1010     packet->len = size; /* FIXME: does header not contain the size? */
1011     return 0;
1012     case packet_class_d2cs:
1013     bn_short_set(&packet->u.d2cs_client.h.size,size);
1014     return 0;
1015     case packet_class_d2gs:
1016     bn_short_set(&packet->u.d2cs_d2gs.h.size,size);
1017     return 0;
1018     case packet_class_d2cs_bnetd:
1019     bn_short_set(&packet->u.d2cs_bnetd.h.size,size);
1020     return 0;
1021     case packet_class_w3route:
1022     if (size!=0 && size<sizeof(t_w3route_header))
1023     {
1024     eventlog(eventlog_level_error,__FUNCTION__,"invalid size %u for w3route packet",size);
1025     return -1;
1026     }
1027     bn_short_set(&packet->u.w3route.h.size,size);
1028     return 0;
1029     default:
1030     eventlog(eventlog_level_error,__FUNCTION__,"packet has invalid class %d",(int)packet->class);
1031     return -1;
1032     }
1033     }
1034    
1035    
1036     extern unsigned int packet_get_header_size(t_packet const * packet)
1037     {
1038     if (!packet)
1039     {
1040     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1041     return MAX_PACKET_SIZE;
1042     }
1043    
1044     switch (packet_get_class(packet))
1045     {
1046     case packet_class_init:
1047     return 0;
1048     case packet_class_bnet:
1049     return sizeof(t_bnet_header);
1050     case packet_class_file:
1051     return sizeof(t_file_header);
1052     case packet_class_udp:
1053     return sizeof(t_udp_header);
1054     case packet_class_raw:
1055     return 0;
1056     case packet_class_d2game:
1057     return 0; /* FIXME: is there no game packet header? */
1058     case packet_class_d2cs:
1059     return sizeof(t_d2cs_client_header);
1060     case packet_class_d2gs:
1061     return sizeof(t_d2cs_d2gs_header);
1062     case packet_class_d2cs_bnetd:
1063     return sizeof(t_d2cs_bnetd_header);
1064     case packet_class_w3route:
1065     return sizeof(t_w3route_header);
1066     default:
1067     eventlog(eventlog_level_error,__FUNCTION__,"packet has bad class %d",(int)packet_get_class(packet));
1068     return MAX_PACKET_SIZE;
1069     }
1070     }
1071    
1072    
1073     extern unsigned int packet_get_flags(t_packet const * packet)
1074     {
1075     if (!packet)
1076     {
1077     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1078     return 0;
1079     }
1080    
1081     return packet->flags;
1082     }
1083    
1084    
1085     extern int packet_set_flags(t_packet * packet, unsigned int flags)
1086     {
1087     if (!packet)
1088     {
1089     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1090     return -1;
1091     }
1092    
1093     packet->flags = flags;
1094     return 0;
1095     }
1096    
1097    
1098     extern int packet_append_string(t_packet * packet, char const * str)
1099     {
1100     unsigned int len;
1101     unsigned short addlen;
1102     unsigned short size;
1103    
1104     if (!packet)
1105     {
1106     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1107     return -1;
1108     }
1109     if (!str)
1110     {
1111     eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
1112     return -1;
1113     }
1114    
1115     len = strlen(str)+1;
1116     size = packet_get_size(packet);
1117     if (size>=MAX_PACKET_SIZE)
1118     return -1;
1119    
1120     if (MAX_PACKET_SIZE-(unsigned int)size>len)
1121     addlen = len;
1122     else
1123     addlen = MAX_PACKET_SIZE-size;
1124     if (addlen<1)
1125     return -1;
1126    
1127     memcpy(packet->u.data+size,str,addlen-1);
1128     packet->u.data[size+addlen-1] = '\0';
1129     packet_set_size(packet,size+addlen);
1130    
1131     return (int)addlen;
1132     }
1133    
1134    
1135     extern int packet_append_ntstring(t_packet * packet, char const * str)
1136     {
1137     unsigned int len;
1138     unsigned short addlen;
1139     unsigned short size;
1140    
1141     if (!packet)
1142     {
1143     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1144     return -1;
1145     }
1146     if (!str)
1147     {
1148     eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
1149     return -1;
1150     }
1151    
1152     len = strlen(str);
1153     size = packet_get_size(packet);
1154     if (size>=MAX_PACKET_SIZE)
1155     return -1;
1156    
1157     if (MAX_PACKET_SIZE-(unsigned int)size>len)
1158     addlen = len;
1159     else
1160     addlen = MAX_PACKET_SIZE-size;
1161     if (addlen<1)
1162     return -1;
1163    
1164     memcpy(packet->u.data+size,str,addlen);
1165     packet_set_size(packet,size+addlen);
1166    
1167     return (int)addlen;
1168     }
1169    
1170    
1171     extern int packet_append_lstr(t_packet * packet, t_lstr *lstr)
1172     {
1173     unsigned short addlen;
1174     unsigned short size;
1175    
1176     if (!packet)
1177     {
1178     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1179     return -1;
1180     }
1181     if (!lstr || !lstr_get_str(lstr))
1182     {
1183     eventlog(eventlog_level_error,__FUNCTION__,"got NULL string");
1184     return -1;
1185     }
1186    
1187     size = packet_get_size(packet);
1188     if (size>=MAX_PACKET_SIZE)
1189     return -1;
1190    
1191     if (MAX_PACKET_SIZE-(unsigned int)size>lstr_get_len(lstr))
1192     addlen = lstr_get_len(lstr);
1193     else
1194     addlen = MAX_PACKET_SIZE-size;
1195     if (addlen<1)
1196     return -1;
1197    
1198     memcpy(packet->u.data+size,lstr_get_str(lstr),addlen-1);
1199     packet->u.data[size+addlen-1] = '\0';
1200     packet_set_size(packet,size+addlen);
1201    
1202     return (int)addlen;
1203     }
1204    
1205    
1206     extern int packet_append_data(t_packet * packet, void const * data, unsigned int len)
1207     {
1208     unsigned short addlen;
1209     unsigned short size;
1210    
1211     if (!packet)
1212     {
1213     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1214     return -1;
1215     }
1216     if (!data)
1217     {
1218     eventlog(eventlog_level_error,__FUNCTION__,"got NULL data");
1219     return -1;
1220     }
1221    
1222     size = packet_get_size(packet);
1223     if (size>=MAX_PACKET_SIZE)
1224     return -1;
1225    
1226     if (MAX_PACKET_SIZE-(unsigned int)size>len)
1227     addlen = len;
1228     else
1229     addlen = MAX_PACKET_SIZE-size;
1230     if (addlen<1)
1231     return -1;
1232    
1233     memcpy(packet->u.data+size,data,addlen);
1234     packet_set_size(packet,size+addlen);
1235    
1236     return (int)addlen;
1237     }
1238    
1239    
1240     extern void const * packet_get_raw_data_const(t_packet const * packet, unsigned int offset)
1241     {
1242     unsigned int size;
1243    
1244     if (!packet)
1245     {
1246     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1247     return NULL;
1248     }
1249     size = (unsigned int)packet_get_size(packet);
1250     if (offset>=size || offset>=MAX_PACKET_SIZE)
1251     {
1252     eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
1253     return NULL;
1254     }
1255    
1256     return packet->u.data+offset;
1257     }
1258    
1259    
1260     extern void * packet_get_raw_data(t_packet * packet, unsigned int offset)
1261     {
1262     unsigned int size;
1263    
1264     if (!packet)
1265     {
1266     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1267     return NULL;
1268     }
1269     size = (unsigned int)packet_get_size(packet);
1270     if (offset>=size || offset>=MAX_PACKET_SIZE)
1271     {
1272     eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
1273     return NULL;
1274     }
1275    
1276     return packet->u.data+offset;
1277     }
1278    
1279    
1280     extern void * packet_get_raw_data_build(t_packet * packet, unsigned int offset)
1281     {
1282     if (!packet)
1283     {
1284     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1285     return NULL;
1286     }
1287    
1288     if (offset>=MAX_PACKET_SIZE)
1289     {
1290     eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet",offset);
1291     return NULL;
1292     }
1293    
1294     return packet->u.data+offset;
1295     }
1296    
1297    
1298     /* maxlen includes room for NUL char */
1299     extern char const * packet_get_str_const(t_packet const * packet, unsigned int offset, unsigned int maxlen)
1300     {
1301     unsigned int size;
1302     unsigned int pos;
1303    
1304     if (!packet)
1305     {
1306     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1307     return NULL;
1308     }
1309     size = (unsigned int)packet_get_size(packet);
1310     if (offset>=size)
1311     {
1312     eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u for packet size %u",offset,size);
1313     return NULL;
1314     }
1315    
1316     for (pos=offset; packet->u.data[pos]!='\0'; pos++)
1317     if (pos>=size || pos-offset>=maxlen)
1318     return NULL;
1319     if (pos>=size || pos-offset>=maxlen) /* NUL must be inside too */
1320     return NULL;
1321     return packet->u.data+offset;
1322     }
1323    
1324    
1325     extern void const * packet_get_data_const(t_packet const * packet, unsigned int offset, unsigned int len)
1326     {
1327     unsigned int size;
1328    
1329     if (!packet)
1330     {
1331     eventlog(eventlog_level_error,__FUNCTION__,"got NULL packet");
1332     return NULL;
1333     }
1334     if (len<1)
1335     {
1336     eventlog(eventlog_level_error,__FUNCTION__,"got zero length");
1337     return NULL;
1338     }
1339     size = (unsigned int)packet_get_size(packet);
1340     if (offset+len>size)
1341     {
1342     eventlog(eventlog_level_error,__FUNCTION__,"got bad offset %u and length %u for packet size %u",offset,len,size);
1343     return NULL;
1344     }
1345    
1346     return packet->u.data+offset;
1347     }
1348    
1349    
1350     extern t_packet * packet_duplicate(t_packet const * src)
1351     {
1352     t_packet * p;
1353    
1354     if (!(p = packet_create(packet_get_class(src))))
1355     {
1356     eventlog(eventlog_level_error,__FUNCTION__,"could not create packet");
1357     return NULL;
1358     }
1359     packet_append_data(p,src->u.data,packet_get_size(src));
1360     packet_set_flags(p,packet_get_flags(src));
1361    
1362     return p;
1363     }
1364    
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1