2 /// \file protostructs.h
3 /// USB Blackberry bulk protocol API. This is split out from
4 /// protocol.h so that low level, packed structs can be
5 /// compiled separately from the application. This prevents
6 /// aliasing problems in the application, or using
7 /// -fno-strict-aliasing, which the library only needs.
9 /// Do not include this in any Barry library header.
10 /// This may only be included from .cc files, in order
11 /// to hide aliasing concernes from the application.
15 Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
17 This program is free software; you can redistribute it and/or modify
18 it under the terms of the GNU General Public License as published by
19 the Free Software Foundation; either version 2 of the License, or
20 (at your option) any later version.
22 This program is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
26 See the GNU General Public License in the COPYING file at the
27 root directory of this project for more details.
30 #ifndef __BARRY_PROTOSTRUCTS_H__
31 #define __BARRY_PROTOSTRUCTS_H__
34 #include <sys/types.h>
36 // forward declarations
37 namespace Barry
{ class Data
; }
39 namespace Barry
{ namespace Protocol
{
41 ///////////////////////////////////////////////////////////////////////////////
46 } __attribute__ ((packed
));
49 ///////////////////////////////////////////////////////////////////////////////
50 // Record sub-field structs
52 struct GroupLink
// used for Contacts records
56 } __attribute__ ((packed
));
58 struct MessageAddress
// used for Message records
61 uint8_t addr
[1]; // 2 null terminated strings: first
62 // contains full name, second contains
64 } __attribute__ ((packed
));
67 ///////////////////////////////////////////////////////////////////////////////
68 // SMS Message field and record structures
72 uint8_t recv
; // if received, this is set to 1; otherwise 0
74 #define SMS_FLG_NEW_CONVERSATION 0x20
75 #define SMS_FLG_SAVED 0x10
76 #define SMS_FLG_DELETED 0x08
77 #define SMS_FLG_OPENED 0x01
80 uint16_t zero
; // constantly 0
82 #define SMS_STA_RECEIVED 0x000007ff
83 #define SMS_STA_DRAFT 0x7fffffff
87 uint64_t service_center_timestamp
;
89 #define SMS_DCS_7BIT 0x00
90 #define SMS_DCS_8BIT 0x01
91 #define SMS_DCS_UCS2 0x02
93 } __attribute__ ((packed
));
94 #define SMS_METADATA_SIZE (sizeof(::Barry::Protocol::SMSMetaData))
98 ///////////////////////////////////////////////////////////////////////////////
99 // Record Field Formats
103 uint16_t size
; // including null terminator
106 union CommonFieldData
111 SMSMetaData sms_metadata
;
120 } __attribute__ ((packed
)) u
;
122 } __attribute__ ((packed
));
123 #define COMMON_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::CommonField) - sizeof(::Barry::Protocol::CommonField::CommonFieldData))
124 #define COMMON_FIELD_MIN1900_SIZE (sizeof(int32_t))
126 struct CommandTableField
128 uint8_t size
; // no null terminator
131 } __attribute__ ((packed
));
132 #define COMMAND_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::CommandTableField) - 1)
138 uint32_t dbSize
; // assumed from Cassis docs...
140 uint16_t dbRecordCount
;
142 uint16_t nameSize
; // includes null terminator
144 } __attribute__ ((packed
));
145 #define OLD_DBDB_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::OldDBDBField) - 1)
151 uint32_t dbSize
; // assumed from Cassis docs...
153 uint32_t dbRecordCount
;
155 uint16_t nameSize
; // includes null terminator
157 uint8_t name
[1]; // followed by 2 zeros!
158 uint16_t unknown
; // this comes after the
159 // null terminated name, but
160 // is here for size calcs
161 } __attribute__ ((packed
));
162 #define DBDB_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::DBDBField) - 1)
164 struct RecordStateTableField
166 uint8_t rectype
; // it is unknown exactly what
167 // this field does, but it
168 // shows up here and in the
169 // tagged record header, and
170 // for some of the records
171 // they must match when writing
173 uint32_t uniqueId
; // matches the uniqueId of say,
174 // address book records
175 uint8_t flags
; // bit 0x01 is the dirty flag
176 // don't know if any other bits
178 #define BARRY_RSTF_DIRTY 0x01
180 } __attribute__ ((packed
));
182 struct CalendarRecurrenceDataField
// as documented in the Cassis project spec
185 #define CRDF_TYPE_DAY 0x01
186 #define CRDF_TYPE_MONTH_BY_DATE 0x03
187 #define CRDF_TYPE_MONTH_BY_DAY 0x04
188 #define CRDF_TYPE_YEAR_BY_DATE 0x05
189 #define CRDF_TYPE_YEAR_BY_DAY 0x06
190 #define CRDF_TYPE_WEEK 0x0c
192 uint8_t unknown
; // always 0x01
195 uint32_t endTime
; // 0xFFFFFFFF for never
199 // Note: blank fields should be set to 0
203 uint8_t day
[6]; // always zeros!
204 } __attribute__ ((packed
)) day
;
208 uint8_t monthDay
; // day of month to recur on
211 } __attribute__ ((packed
)) month_by_date
;
215 uint8_t weekDay
; // day of week to recur on (0-6)
216 uint8_t week
; // week of month to recur on
217 // (1 to 5, first week, second
220 } __attribute__ ((packed
)) month_by_day
;
224 uint8_t monthDay
; // day of month to recur on
227 uint8_t month
; // month to recur on (1-12)
229 } __attribute__ ((packed
)) year_by_date
;
233 uint8_t weekDay
; // day of week to recur on (0-6)
234 uint8_t week
; // week of month (1 to 5)
235 uint8_t month
; // (1-12)
237 } __attribute__ ((packed
)) year_by_day
;
241 uint8_t days
; // bitmask
242 #define CRDF_WD_SUN 0x01
243 #define CRDF_WD_MON 0x02
244 #define CRDF_WD_TUE 0x04
245 #define CRDF_WD_WED 0x08
246 #define CRDF_WD_THU 0x10
247 #define CRDF_WD_FRI 0x20
248 #define CRDF_WD_SAT 0x40
251 } __attribute__ ((packed
)) week
;
253 } __attribute__ ((packed
)) u
;
255 } __attribute__ ((packed
));
256 #define CALENDAR_RECURRENCE_DATA_FIELD_SIZE sizeof(::Barry::Protocol::CalendarRecurrenceDataField)
259 // Calendar record: field constants
262 #define CR_FREEBUSY_FREE 0
263 #define CR_FREEBUSY_TENTATIVE 1
264 #define CR_FREEBUSY_BUSY 2
265 #define CR_FREEBUSY_OUT_OF_OFFICE 3
266 #define CR_FREEBUSY_RANGE_LOW 0
267 #define CR_FREEBUSY_RANGE_HIGH 3
269 #define CR_CLASS_PUBLIC 0
270 #define CR_CLASS_CONFIDENTIAL 1
271 #define CR_CLASS_PRIVATE 2
272 #define CR_CLASS_RANGE_LOW 0
273 #define CR_CLASS_RANGE_HIGH 2
277 // Task record: field constants
280 #define TR_ALARM_DATE 1
281 #define TR_ALARM_RELATIVE 2
282 #define TR_ALARM_RANGE_LOW 1
283 #define TR_ALARM_RANGE_HIGH 2
285 #define TR_PRIORITY_HIGH 0
286 #define TR_PRIORITY_NORMAL 1
287 #define TR_PRIORITY_LOW 2
288 #define TR_PRIORITY_RANGE_LOW 0
289 #define TR_PRIORITY_RANGE_HIGH 2
291 #define TR_STATUS_NOT_STARTED 0
292 #define TR_STATUS_IN_PROGRESS 1
293 #define TR_STATUS_COMPLETED 2
294 #define TR_STATUS_WAITING 3
295 #define TR_STATUS_DEFERRED 4
296 #define TR_STATUS_RANGE_LOW 0
297 #define TR_STATUS_RANGE_HIGH 4
300 // Phone Call Logs record: field constants
303 #define CLL_DIRECTION_RECEIVER 0
304 #define CLL_DIRECTION_EMITTER 1
305 #define CLL_DIRECTION_FAILED 2
306 #define CLL_DIRECTION_MISSING 3
307 #define CLL_DIRECTION_RANGE_LOW 0
308 #define CLL_DIRECTION_RANGE_HIGH 3
310 #define CLL_PHONETYPE_UNDEFINED 0
311 #define CLL_PHONETYPE_OFFICE 1
312 #define CLL_PHONETYPE_HOME 2
313 #define CLL_PHONETYPE_MOBILE 3
314 #define CLL_PHONETYPE_RANGE_LOW 0
315 #define CLL_PHONETYPE_RANGE_HIGH 3
318 // Folder record: field constants
321 #define FR_TYPE_SUBTREE 0x00
322 #define FR_TYPE_DELETED 0x01
323 #define FR_TYPE_INBOX 0x02
324 #define FR_TYPE_OUTBOX 0x03
325 #define FR_TYPE_SENT 0x04
326 #define FR_TYPE_OTHER 0x05
327 #define FR_TYPE_DRAFT 0x0a
329 #define FR_STATUS_ORPHAN 0x50
330 #define FR_STATUS_UNFILED 0x51
331 #define FR_STATUS_FILED 0x52
334 ///////////////////////////////////////////////////////////////////////////////
335 // Packed field structures - odd format used with Service Book records
337 struct PackedField_02
343 } __attribute__ ((packed
));
344 #define PACKED_FIELD_02_HEADER_SIZE (sizeof(::Barry::Protocol::PackedField_02) - 1)
346 struct PackedField_10
351 } __attribute__ ((packed
));
352 #define PACKED_FIELD_10_HEADER_SIZE (sizeof(::Barry::Protocol::PackedField_10) - 1)
357 ///////////////////////////////////////////////////////////////////////////////
358 // Service Book field and record structures
360 struct ServiceBookConfigField
364 } __attribute__ ((packed
));
365 #define SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::ServiceBookConfigField) - 1)
368 ///////////////////////////////////////////////////////////////////////////////
369 // DB Command Parameter structures
373 uint16_t recordIndex
; // index comes from RecordStateTable
375 } __attribute__ ((packed
));
376 #define DBC_RECORD_HEADER_SIZE (sizeof(::Barry::Protocol::DBC_Record) - 1)
378 struct DBC_RecordFlags
383 } __attribute__ ((packed
));
384 #define DBC_RECORD_FLAGS_SIZE (sizeof(::Barry::Protocol::DBC_RecordFlags))
386 struct DBC_TaggedUpload
388 uint8_t rectype
; // it is unknown exactly what
389 // this field does, but it
390 // shows up here and in the
391 // RecordStateTable, and
392 // for some of the records
393 // they must match when writing
397 } __attribute__ ((packed
));
398 #define DBC_TAGGED_UPLOAD_HEADER_SIZE (sizeof(::Barry::Protocol::DBC_TaggedUpload) - 1)
400 struct DBC_IndexedUpload
402 uint8_t unknown
; // observed: 00 or 05
405 } __attribute__ ((packed
));
406 #define DBC_INDEXED_UPLOAD_HEADER_SIZE (sizeof(::Barry::Protocol::DBC_IndexedUpload) - 1)
408 struct PasswordChallenge
410 uint8_t remaining_tries
; // number of password attempts
411 // the device will accept before
412 // committing suicide...
413 // starts at 10 and counts down
414 // on each bad password
415 uint8_t unknown
; // observed as 0... probably just
416 // the top byte of a uint16
417 // remaining_tries, but I don't
418 // want to take that chance
419 uint16_t param
; // seems to be a secondary command
420 // of some kind, observed as 0x14
421 // or 0x04, but purpose unknown
422 // possibly a send/receive flag
428 } __attribute__ ((packed
)) u
;
430 } __attribute__ ((packed
));
431 #define PASSWORD_CHALLENGE_HEADER_SIZE (sizeof(::Barry::Protocol::PasswordChallenge) - sizeof(::Barry::Protocol::PasswordChallenge::Hash))
432 #define PASSWORD_CHALLENGE_SEED_SIZE (PASSWORD_CHALLENGE_HEADER_SIZE + sizeof(uint32_t))
433 #define PASSWORD_CHALLENGE_SIZE (sizeof(::Barry::Protocol::PasswordChallenge))
435 struct AttributeFetch
439 uint8_t raw
[1]; // used only in response
440 } __attribute__ ((packed
));
441 #define ATTRIBUTE_FETCH_COMMAND_SIZE (sizeof(::Barry::Protocol::AttributeFetch) - 1)
449 } __attribute__ ((packed
)) response
;
450 } __attribute__ ((packed
));
454 uint64_t ticks
; // number of microseconds since
455 // host system startup
456 } __attribute__ ((packed
));
457 #define ECHO_COMMAND_SIZE (sizeof(::Barry::Protocol::Echo))
460 ///////////////////////////////////////////////////////////////////////////////
461 // Protocol command structures
466 uint8_t sequence
; // incremented on each socket 0
467 // communication, replies return
468 // the same number from command
473 PasswordChallenge password
;
474 AttributeFetch fetch
;
479 } __attribute__ ((packed
)) u
;
480 } __attribute__ ((packed
));
481 #define SOCKET_COMMAND_HEADER_SIZE (sizeof(::Barry::Protocol::SocketCommand) - sizeof(::Barry::Protocol::SocketCommand::PacketData))
483 struct SequenceCommand
489 } __attribute__ ((packed
));
493 uint8_t operation
; // see below
494 uint16_t databaseId
; // value from the Database Database
500 DBC_RecordFlags flags
;
501 DBC_TaggedUpload tag_upload
;
502 DBC_IndexedUpload index_upload
;
505 } __attribute__ ((packed
)) u
;
506 } __attribute__ ((packed
));
507 #define DB_COMMAND_HEADER_SIZE (sizeof(::Barry::Protocol::DBCommand) - sizeof(::Barry::Protocol::DBCommand::Parameters))
511 ///////////////////////////////////////////////////////////////////////////////
512 // Protocol response parameter structures
514 struct DBR_OldDBDBRecord
516 uint16_t count
; // number of fields in record
517 OldDBDBField field
[1];
518 } __attribute__ ((packed
));
519 #define OLD_DBDB_RECORD_HEADER_SIZE (sizeof(::Barry::Protocol::DBR_OldDBDBRecord) - sizeof(::Barry::Protocol::OldDBDBField))
521 struct DBR_DBDBRecord
526 } __attribute__ ((packed
));
527 #define DBDB_RECORD_HEADER_SIZE (sizeof(::Barry::Protocol::DBR_DBDBRecord) - sizeof(::Barry::Protocol::DBDBField))
529 // Records with a uniqueId. This covers the following records:
531 // Old Contact records
532 // Old Service Book records
533 // Old Calendar records
535 struct DBR_OldTaggedRecord
544 CommonField field
[1];
545 } __attribute__ ((packed
)) u
;
546 } __attribute__ ((packed
));
547 #define DBR_OLD_TAGGED_RECORD_HEADER_SIZE (sizeof(::Barry::Protocol::DBR_OldTaggedRecord) - sizeof(::Barry::Protocol::DBR_OldTaggedRecord::TaggedData))
551 uint8_t field1
; // always 'j'
552 uint32_t field2
; // always 0x00000000
553 uint32_t flags
; // flags
554 uint32_t field4
; // normal email and pin recv this is 0x7ff
555 // changes on sent and reply to 0x01ffffff
556 // and 0x003fffff on pin send
557 uint32_t field5
; // always 0x00000000
558 uint32_t field6
; // always 0x00000000
559 uint32_t field7
; // always 0x00000000
560 uint32_t field8
; // always 0x00000000
561 uint16_t field9
; // always 0x0000
563 uint16_t dateReceived
; // the first two of these time fields are always the same
564 uint16_t timeReceived
; //
565 uint16_t dateDuplicate
; // On mail sent from the BB all three fields are identical
566 uint16_t timeDuplicate
; // (time sent)
570 uint16_t priority
; // priority field
571 uint32_t field14
; // always 0x00000000
572 uint32_t field15
; // always 0x00000000
573 uint16_t field16
; // always 0x0000
574 uint32_t field13
; // PIN reply 0x00000000 other time 0xffffffff or 0xfffffffe
575 uint16_t messageSize
; // Message size, 0x0000 if Reply or Saved, 0xffff if below ????
576 uint32_t field18
; // 0x0's and 0xF'x
577 uint32_t field19
; // 0x0's and 0xF's
578 uint16_t field20
; // always 0x0000
579 uint16_t field21
; // 0x01 unless PIN reply then 0x00
580 uint32_t inReplyTo
; // reply to message?
581 uint32_t field22
; // always 0x00000000
582 uint16_t field23
; // FIXME
584 uint32_t folderOne
; // these are the 'folders' the message is in
585 uint32_t folderTwo
; //
587 uint16_t replyMessageFlags
; // 0xfffe on recvd messages
592 uint16_t field27
; // set to 0x00000004 on PIN reply, 0x00000005 otherwise
593 uint32_t headerUID
; // yet another copy of the UID (RecId)
595 uint32_t field29
; // always 0x00000000
596 uint16_t field30
; // always 0x0002
597 uint16_t field31
; // always 0x00000000
598 uint16_t field32
; // always 0x0004
599 uint16_t field34
; // always 0x0000
600 uint8_t field33
; // always 'd'
601 uint32_t timeBlock
; // FIXME
602 CommonField field
[1];
603 } __attribute__ ((packed
));
604 #define MESSAGE_RECORD_HEADER_SIZE (sizeof(::Barry::Protocol::MessageRecord) - sizeof(::Barry::Protocol::CommonField))
608 ///////////////////////////////////////////////////////////////////////////////
609 // Protocol response structures
618 DBR_OldTaggedRecord tagged
;
619 DBR_OldDBDBRecord old_dbdb
;
622 } __attribute__ ((packed
)) u
;
624 } __attribute__ ((packed
));
625 #define DB_RESPONSE_HEADER_SIZE (sizeof(::Barry::Protocol::DBResponse) - sizeof(::Barry::Protocol::DBResponse::Parameters))
629 ///////////////////////////////////////////////////////////////////////////////
630 // Database access command structure
632 // even fragmented packets have a tableCmd
641 CommandTableField table
[1];
645 } __attribute__ ((packed
)) u
;
646 } __attribute__ ((packed
));
647 #define SB_DBACCESS_HEADER_SIZE (sizeof(::Barry::Protocol::DBAccess) - sizeof(::Barry::Protocol::DBAccess::DBData))
648 #define SB_DBACCESS_RETURN_CODE_SIZE (1)
652 ///////////////////////////////////////////////////////////////////////////////
653 // Javaloader protocol structure
659 uint16_t filename_size
;
661 // the rest of the packet is variable length
662 // another string for version, then:
663 // uint32_t cod_size;
665 } __attribute__ ((packed
));
666 #define SB_JLDIRENTRY_HEADER_SIZE (sizeof(::Barry::Protocol::JLDirEntry) - 1)
671 uint8_t unknown
; // nearly always 0, might be top half of command
673 } __attribute__ ((packed
));
674 #define SB_JLCOMMAND_HEADER_SIZE (sizeof(::Barry::Protocol::JLCommand))
681 } __attribute__ ((packed
));
682 #define SB_JLRESPONSE_HEADER_SIZE (sizeof(::Barry::Protocol::JLResponse))
694 } __attribute__ ((packed
));
695 #define SB_JLSCREENINFO_SIZE (sizeof(::Barry::Protocol::JLScreenInfo))
697 struct JLEventlogEntry
700 // remainder of packet is variable
701 // it contains the log data as an ASCII (UTF-8?) string
702 } __attribute__ ((packed
));
703 #define SB_JLEVENTLOG_ENTRY_HEADER_SIZE (sizeof(::Barry::Protocol::JLEventlogEntry))
707 uint32_t hardware_id
;
713 uint32_t active_wafs
;
714 // older devices (such as 7130) don't this extra data in the
715 // device info packet and will therefore fail the size check
717 } __attribute__ ((packed
));
718 #define SB_JLDEVICEINFO_SIZE (sizeof(::Barry::Protocol::JLDeviceInfo))
723 uint16_t size
; // total size of data packet
729 JLScreenInfo screeninfo
;
730 JLEventlogEntry logentry
;
731 JLDeviceInfo devinfo
;
737 } __attribute__ ((packed
)) u
;
739 } __attribute__ ((packed
));
740 #define SB_JLPACKET_HEADER_SIZE (sizeof(::Barry::Protocol::JLPacket) - sizeof(::Barry::Protocol::JLPacket::PacketData))
743 ///////////////////////////////////////////////////////////////////////////////
744 // JavaDebug protocol structures
751 struct PacketEventRequestSet
{
753 uint8_t suspendPolicy
;
755 } __attribute__ ((packed
));
758 struct PacketEventRequest
{
759 union PacketEventRequestData
{
760 PacketEventRequestSet set
;
761 } __attribute__ ((packed
)) u
;
762 } __attribute__ ((packed
));
765 struct PacketCommand
{
769 union PacketCommandData
{
770 PacketEventRequest eventRequest
;
771 } __attribute__ ((packed
)) u
;
772 } __attribute__ ((packed
));
773 #define JDWP_COMMAND_HEADER_SIZE (sizeof(::Barry::Protocol::JDWP::PacketCommand))
779 struct PacketVirtualMachineIDSizes
{
780 uint32_t fieldIDSize
;
781 uint32_t methodIDSize
;
782 uint32_t objectIDSize
;
783 uint32_t referenceTypeIDSize
;
784 uint32_t frameIDSize
;
785 } __attribute__ ((packed
));
787 #define JDWP_PACKETVIRTUALMACHINEIDSIZES_DATA_SIZE sizeof(::Barry::Protocol::JDWP::PacketVirtualMachineIDSizes)
790 struct PacketVirtualMachine
{
791 union PacketVirtualMachineData
{
792 PacketVirtualMachineIDSizes IDSizes
;
793 } __attribute__ ((packed
)) u
;
794 } __attribute__ ((packed
));
797 struct PacketResponse
{
800 union PacketResponseData
{
801 PacketVirtualMachine virtualMachine
;
804 } __attribute__ ((packed
)) u
;
805 } __attribute__ ((packed
));
806 #define JDWP_RESPONSE_HEADER_SIZE (sizeof(::Barry::Protocol::JDWP::PacketResponse) - sizeof(::Barry::Protocol::JDWP::PacketResponse::PacketResponseData))
818 PacketCommand command
;
819 PacketResponse response
;
820 } __attribute__ ((packed
)) u
;
821 } __attribute__ ((packed
));
822 #define JDWP_PACKET_HEADER_SIZE (sizeof(::Barry::Protocol::JDWP::Packet) - sizeof(::Barry::Protocol::JDWP::Packet::PacketType))
825 #define MAKE_JDWPPACKET(var, data) const ::Barry::Protocol::JDWP::Packet *var = (const ::Barry::Protocol::JDWP::Packet *) (data).GetData()
826 #define MAKE_JDWPPACKETPTR_BUF(var, ptr) ::Barry::Protocol::JDWP::Packet *var = (::Barry::Protocol::JDWP::Packet *)ptr
836 } __attribute__ ((packed
)) u
;
837 } __attribute__ ((packed
));
838 #define JDWP_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::JDWField) - sizeof(::Barry::Protocol::JDWField::JDWFieldData))
845 } __attribute__ ((packed
));
846 #define SB_JVMCOMMAND_HEADER_SIZE (sizeof(::Barry::Protocol::JVMCommand))
853 } __attribute__ ((packed
));
854 #define SB_JVMRESPONSE_HEADER_SIZE (sizeof(::Barry::Protocol::JVMResponse))
856 struct JVMModulesList
859 // remainder of packet is variable
860 // it contains the modules list
861 } __attribute__ ((packed
));
862 #define SB_JVMMODULES_LIST_HEADER_SIZE (sizeof(::Barry::Protocol::JVMModulesList))
864 struct JVMModulesEntry
869 // remainder of packet is variable
870 // it contains the module name
871 } __attribute__ ((packed
));
872 #define SB_JVMMODULES_ENTRY_HEADER_SIZE (sizeof(::Barry::Protocol::JVMModulesEntry))
874 struct JVMThreadsList
877 // remainder of packet is variable
878 // it contains the threads list
879 } __attribute__ ((packed
));
880 #define SB_JVMTHREADS_LIST_HEADER_SIZE (sizeof(::Barry::Protocol::JVMThreadsList))
886 } __attribute__ ((packed
));
887 #define SB_JVMUNKNOWN01_HEADER_SIZE (sizeof(::Barry::Protocol::JVMUnknown01))
893 } __attribute__ ((packed
));
894 #define SB_JVMUNKNOWN02_HEADER_SIZE (sizeof(::Barry::Protocol::JVMUnknown02))
899 uint16_t size
; // total size of data packet
904 JVMResponse response
;
905 JVMModulesList moduleslist
;
906 JVMThreadsList threadslist
;
907 JVMUnknown01 unknown01
;
908 JVMUnknown02 unknown02
;
915 } __attribute__ ((packed
)) u
;
917 } __attribute__ ((packed
));
918 #define SB_JVMPACKET_HEADER_SIZE (sizeof(::Barry::Protocol::JVMPacket) - sizeof(::Barry::Protocol::JVMPacket::PacketData))
921 ///////////////////////////////////////////////////////////////////////////////
922 // Main packet struct
926 uint16_t socket
; // socket ID... 0 exists by default
927 uint16_t size
; // total size of data packet
933 SocketCommand socket
;
934 SequenceCommand sequence
;
938 } __attribute__ ((packed
)) u
;
939 } __attribute__ ((packed
));
940 #define SB_PACKET_HEADER_SIZE (sizeof(::Barry::Protocol::Packet) - sizeof(::Barry::Protocol::Packet::PacketData))
942 // WARNING : For JavaLoader we have some packet with 5 size !
943 #define MIN_PACKET_SIZE 5
944 #define MIN_PACKET_DATA_SIZE 4
948 #define MAX_PACKET_SIZE 0x400 // anything beyond this needs to be fragmented
949 #define MAX_PACKET_DATA_SIZE 0x7FC // for data packet (JavaLoader)
951 /////////////////////////////////////////////////////////////////////////////
953 // various useful sizes
956 #define SB_PACKET_DBACCESS_HEADER_SIZE (SB_PACKET_HEADER_SIZE + SB_DBACCESS_HEADER_SIZE)
957 #define SB_FRAG_HEADER_SIZE SB_PACKET_DBACCESS_HEADER_SIZE
959 #define SB_PACKET_COMMAND_HEADER_SIZE (SB_PACKET_DBACCESS_HEADER_SIZE + DB_COMMAND_HEADER_SIZE)
960 #define SB_PACKET_RESPONSE_HEADER_SIZE (SB_PACKET_DBACCESS_HEADER_SIZE + DB_RESPONSE_HEADER_SIZE)
962 #define SB_PACKET_DBDB_HEADER_SIZE (SB_PACKET_RESPONSE_HEADER_SIZE + DBDB_RECORD_HEADER_SIZE)
963 #define SB_PACKET_OLD_DBDB_HEADER_SIZE (SB_PACKET_RESPONSE_HEADER_SIZE + OLD_DBDB_RECORD_HEADER_SIZE)
965 #define SB_PACKET_UPLOAD_HEADER_SIZE (SB_PACKET_DBACCESS_HEADER_SIZE + UPLOAD_HEADER_SIZE)
967 #define SB_SEQUENCE_PACKET_SIZE (SB_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::SequenceCommand))
968 #define SB_SOCKET_PACKET_HEADER_SIZE (SB_PACKET_HEADER_SIZE + SOCKET_COMMAND_HEADER_SIZE)
969 #define SB_MODE_PACKET_COMMAND_SIZE (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::ModeSelect) - sizeof(::Barry::Protocol::ModeSelect::ResponseBlock))
970 #define SB_MODE_PACKET_RESPONSE_SIZE (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::ModeSelect))
974 #define COMMAND(data) (((const ::Barry::Protocol::Packet *)data.GetData())->command)
975 #define IS_COMMAND(data, cmd) (COMMAND(data) == cmd)
976 #define MAKE_PACKET(var, data) const ::Barry::Protocol::Packet *var = (const ::Barry::Protocol::Packet *) (data).GetData()
977 #define MAKE_JLPACKET(var, data) const ::Barry::Protocol::JLPacket *var = (const ::Barry::Protocol::JLPacket *) (data).GetData()
978 #define MAKE_JVMPACKET(var, data) const ::Barry::Protocol::JVMPacket *var = (const ::Barry::Protocol::JVMPacket *) (data).GetData()
979 #define MAKE_PACKETPTR_BUF(var, ptr) ::Barry::Protocol::Packet *var = (::Barry::Protocol::Packet *)ptr
980 #define MAKE_JLPACKETPTR_BUF(var, ptr) ::Barry::Protocol::JLPacket *var = (::Barry::Protocol::JLPacket *)ptr
981 #define MAKE_JVMPACKETPTR_BUF(var, ptr) ::Barry::Protocol::JVMPacket *var = (::Barry::Protocol::JVMPacket *)ptr
982 #define MAKE_RECORD(type,var,data,off) type *var = (type *) ((data).GetData() + (off))
983 #define MAKE_RECORD_PTR(type,var,data,off) type *var = (type *) ((data) + (off))
985 // fragmentation protocol
986 // send DATA first, then keep sending DATA packets, FRAGMENTing
987 // as required until finished, then send DONE. Both sides behave
988 // this way, so different sized data can be sent in both
991 // the fragmented piece only has a the param header, and then continues
992 // right on with the data
996 // checks packet size and throws BError if not right
997 void CheckSize(const Barry::Data
&packet
, size_t requiredsize
);
998 unsigned int GetSize(const Barry::Data
&packet
);
1000 }} // namespace Barry::Protocol