src/protostructs.h

   1 ///
   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.
   8 ///
   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.
  12 ///
  13
  14 /*
  15     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
  16
  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.
  21
  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.
  25
  26     See the GNU General Public License in the COPYING file at the
  27     root directory of this project for more details.
  28 */
  29
  30 #ifndef __BARRY_PROTOSTRUCTS_H__
  31 #define __BARRY_PROTOSTRUCTS_H__
  32
  33 #include <stdint.h>
  34 #include <sys/types.h>
  35
  36 // forward declarations
  37 namespace Barry { class Data; }
  38
  39 namespace Barry { namespace Protocol {
  40
  41 ///////////////////////////////////////////////////////////////////////////////
  42 union SizePacket
  43 {
  44         uint16_t size;
  45         char buffer[4];
  46 } __attribute__ ((packed));
  47
  48
  49 ///////////////////////////////////////////////////////////////////////////////
  50 // Record sub-field structs
  51
  52 struct GroupLink                                // used for Contacts records
  53 {
  54         uint32_t        uniqueId;
  55         uint16_t        unknown;
  56 } __attribute__ ((packed));
  57
  58 struct MessageAddress                           // used for Message records
  59 {
  60         uint8_t         unknown[8];
  61         uint8_t         addr[1];        // 2 null terminated strings: first
  62                                         // contains full name, second contains
  63                                         // the email address
  64 } __attribute__ ((packed));
  65
  66
  67 ///////////////////////////////////////////////////////////////////////////////
  68 // SMS Message field and record structures
  69
  70 struct SMSMetaData
  71 {
  72         uint8_t         recv; // if received, this is set to 1; otherwise 0
  73         uint8_t         flags;
  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
  78
  79         uint8_t         new_flag;
  80         uint16_t        zero; // constantly 0
  81         uint32_t        status;
  82 #define SMS_STA_RECEIVED 0x000007ff
  83 #define SMS_STA_DRAFT 0x7fffffff
  84
  85         uint32_t        error_id;
  86         uint64_t        timestamp;
  87         uint64_t        service_center_timestamp;
  88         uint8_t         dcs;
  89 #define SMS_DCS_7BIT 0x00
  90 #define SMS_DCS_8BIT 0x01
  91 #define SMS_DCS_UCS2 0x02
  92
  93 } __attribute__ ((packed));
  94 #define SMS_METADATA_SIZE       (sizeof(::Barry::Protocol::SMSMetaData))
  95
  96
  97
  98 ///////////////////////////////////////////////////////////////////////////////
  99 // Record Field Formats
 100
 101 struct CommonField
 102 {
 103         uint16_t        size;                   // including null terminator
 104         uint8_t         type;
 105
 106         union CommonFieldData
 107         {
 108
 109                 GroupLink       link;
 110                 MessageAddress  addr;
 111                 SMSMetaData     sms_metadata;
 112                 uint64_t        timestamp;
 113                 uint64_t        uint64;
 114                 uint32_t        uint32;
 115                 int32_t         min1900;
 116                 uint16_t        code;
 117                 uint8_t         raw[1];
 118                 int16_t         int16;
 119
 120         } __attribute__ ((packed)) u;
 121
 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))
 125
 126 struct CommandTableField
 127 {
 128         uint8_t         size;           // no null terminator
 129         uint8_t         code;
 130         uint8_t         name[1];
 131 } __attribute__ ((packed));
 132 #define COMMAND_FIELD_HEADER_SIZE       (sizeof(::Barry::Protocol::CommandTableField) - 1)
 133
 134 struct OldDBDBField
 135 {
 136         uint16_t        dbNumber;
 137         uint8_t         unknown1;
 138         uint32_t        dbSize;                 // assumed from Cassis docs...
 139                                                 // always 0 in USB
 140         uint16_t        dbRecordCount;
 141         uint16_t        unknown2;
 142         uint16_t        nameSize;               // includes null terminator
 143         uint8_t         name[1];
 144 } __attribute__ ((packed));
 145 #define OLD_DBDB_FIELD_HEADER_SIZE      (sizeof(::Barry::Protocol::OldDBDBField) - 1)
 146
 147 struct DBDBField
 148 {
 149         uint16_t        dbNumber;
 150         uint8_t         unknown1;
 151         uint32_t        dbSize;                 // assumed from Cassis docs...
 152                                                 // always 0 in USB
 153         uint32_t        dbRecordCount;
 154         uint16_t        unknown2;
 155         uint16_t        nameSize;               // includes null terminator
 156         uint8_t         unknown3;
 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)
 163
 164 struct RecordStateTableField
 165 {
 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
 172         uint16_t        index;
 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
 177                                                 // are used
 178 #define BARRY_RSTF_DIRTY        0x01
 179         uint8_t         unknown2[4];
 180 } __attribute__ ((packed));
 181
 182 struct CalendarRecurrenceDataField  // as documented in the Cassis project spec
 183 {
 184         uint8_t         type;
 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
 191
 192         uint8_t         unknown;                // always 0x01
 193         uint16_t        interval;
 194         uint32_t        startTime;
 195         uint32_t        endTime;                // 0xFFFFFFFF for never
 196
 197         union Additional
 198         {
 199                 // Note: blank fields should be set to 0
 200
 201                 struct Day
 202                 {
 203                         uint8_t day[6];         // always zeros!
 204                 } __attribute__ ((packed)) day;
 205
 206                 struct MonthByDate
 207                 {
 208                         uint8_t monthDay;       // day of month to recur on
 209                                                 // (1-31)
 210                         uint8_t blank[5];
 211                 } __attribute__ ((packed)) month_by_date;
 212
 213                 struct MonthByDay
 214                 {
 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
 218                                                 // week, etc)
 219                         uint8_t blank[4];
 220                 } __attribute__ ((packed)) month_by_day;
 221
 222                 struct YearByDate
 223                 {
 224                         uint8_t monthDay;       // day of month to recur on
 225                                                 // (1-31)
 226                         uint8_t blank;
 227                         uint8_t month;          // month to recur on (1-12)
 228                         uint8_t blank_[3];
 229                 } __attribute__ ((packed)) year_by_date;
 230
 231                 struct YearByDay
 232                 {
 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)
 236                         uint8_t blank[3];
 237                 } __attribute__ ((packed)) year_by_day;
 238
 239                 struct Week
 240                 {
 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
 249
 250                         uint8_t blank[5];
 251                 } __attribute__ ((packed)) week;
 252
 253         } __attribute__ ((packed)) u;
 254
 255 } __attribute__ ((packed));
 256 #define CALENDAR_RECURRENCE_DATA_FIELD_SIZE     sizeof(::Barry::Protocol::CalendarRecurrenceDataField)
 257
 258 //
 259 // Calendar record: field constants
 260 //
 261
 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
 268
 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
 274
 275
 276 //
 277 // Task record: field constants
 278 //
 279
 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
 284
 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
 290
 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
 298
 299 //
 300 // Phone Call Logs record: field constants
 301 //
 302 //
 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
 309
 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
 316
 317 //
 318 // Folder record: field constants
 319 //
 320
 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
 328
 329 #define FR_STATUS_ORPHAN                0x50
 330 #define FR_STATUS_UNFILED               0x51
 331 #define FR_STATUS_FILED                 0x52
 332
 333
 334 ///////////////////////////////////////////////////////////////////////////////
 335 // Packed field structures - odd format used with Service Book records
 336
 337 struct PackedField_02
 338 {
 339         uint8_t         code;
 340         uint8_t         size;
 341         uint8_t         type;
 342         uint8_t         raw[1];
 343 } __attribute__ ((packed));
 344 #define PACKED_FIELD_02_HEADER_SIZE     (sizeof(::Barry::Protocol::PackedField_02) - 1)
 345
 346 struct PackedField_10
 347 {
 348         uint8_t         type;
 349         uint8_t         size;
 350         uint8_t         raw[1];
 351 } __attribute__ ((packed));
 352 #define PACKED_FIELD_10_HEADER_SIZE     (sizeof(::Barry::Protocol::PackedField_10) - 1)
 353
 354
 355
 356
 357 ///////////////////////////////////////////////////////////////////////////////
 358 // Service Book field and record structures
 359
 360 struct ServiceBookConfigField
 361 {
 362         uint8_t         format;
 363         uint8_t         fields[1];
 364 } __attribute__ ((packed));
 365 #define SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE (sizeof(::Barry::Protocol::ServiceBookConfigField) - 1)
 366
 367
 368 ///////////////////////////////////////////////////////////////////////////////
 369 // DB Command Parameter structures
 370
 371 struct DBC_Record
 372 {
 373         uint16_t        recordIndex;    // index comes from RecordStateTable
 374         uint8_t         data[1];
 375 } __attribute__ ((packed));
 376 #define DBC_RECORD_HEADER_SIZE          (sizeof(::Barry::Protocol::DBC_Record) - 1)
 377
 378 struct DBC_RecordFlags
 379 {
 380         uint8_t         unknown;
 381         uint16_t        index;
 382         uint8_t         unknown2[5];
 383 } __attribute__ ((packed));
 384 #define DBC_RECORD_FLAGS_SIZE           (sizeof(::Barry::Protocol::DBC_RecordFlags))
 385
 386 struct DBC_TaggedUpload
 387 {
 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
 394         uint32_t        uniqueId;
 395         uint8_t         unknown2;
 396         uint8_t         data[1];
 397 } __attribute__ ((packed));
 398 #define DBC_TAGGED_UPLOAD_HEADER_SIZE   (sizeof(::Barry::Protocol::DBC_TaggedUpload) - 1)
 399
 400 struct DBC_IndexedUpload
 401 {
 402         uint8_t         unknown;        // observed: 00 or 05
 403         uint16_t        index;
 404         uint8_t         data[1];
 405 } __attribute__ ((packed));
 406 #define DBC_INDEXED_UPLOAD_HEADER_SIZE  (sizeof(::Barry::Protocol::DBC_IndexedUpload) - 1)
 407
 408 struct PasswordChallenge
 409 {
 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
 423                                                 // bit (0x10/0x00)
 424         union Hash
 425         {
 426                 uint32_t        seed;
 427                 uint8_t         hash[20];
 428         } __attribute__ ((packed)) u;
 429
 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))
 434
 435 struct AttributeFetch
 436 {
 437         uint16_t        object;
 438         uint16_t        attribute;
 439         uint8_t         raw[1];                 // used only in response
 440 } __attribute__ ((packed));
 441 #define ATTRIBUTE_FETCH_COMMAND_SIZE    (sizeof(::Barry::Protocol::AttributeFetch) - 1)
 442
 443 struct ModeSelect
 444 {
 445         uint8_t         name[16];
 446         struct ResponseBlock
 447         {
 448                 uint8_t         unknown[20];
 449         } __attribute__ ((packed)) response;
 450 } __attribute__ ((packed));
 451
 452 struct Echo
 453 {
 454         uint64_t        ticks;                  // number of microseconds since
 455                                                 // host system startup
 456 } __attribute__ ((packed));
 457 #define ECHO_COMMAND_SIZE               (sizeof(::Barry::Protocol::Echo))
 458
 459
 460 ///////////////////////////////////////////////////////////////////////////////
 461 // Protocol command structures
 462
 463 struct SocketCommand
 464 {
 465         uint16_t        socket;
 466         uint8_t         sequence;               // incremented on each socket 0
 467                                                 // communication, replies return
 468                                                 // the same number from command
 469
 470         union PacketData
 471         {
 472
 473                 PasswordChallenge       password;
 474                 AttributeFetch          fetch;
 475                 ModeSelect              mode;
 476                 uint8_t                 raw[1];
 477                 Echo                    echo;
 478
 479         } __attribute__ ((packed)) u;
 480 } __attribute__ ((packed));
 481 #define SOCKET_COMMAND_HEADER_SIZE              (sizeof(::Barry::Protocol::SocketCommand) - sizeof(::Barry::Protocol::SocketCommand::PacketData))
 482
 483 struct SequenceCommand
 484 {
 485         uint8_t         unknown1;
 486         uint8_t         unknown2;
 487         uint8_t         unknown3;
 488         uint32_t        sequenceId;
 489 } __attribute__ ((packed));
 490
 491 struct DBCommand
 492 {
 493         uint8_t         operation;      // see below
 494         uint16_t        databaseId;     // value from the Database Database
 495
 496         union Parameters
 497         {
 498
 499                 DBC_Record              record;
 500                 DBC_RecordFlags         flags;
 501                 DBC_TaggedUpload        tag_upload;
 502                 DBC_IndexedUpload       index_upload;
 503                 uint8_t                 raw[1];
 504
 505         } __attribute__ ((packed)) u;
 506 } __attribute__ ((packed));
 507 #define DB_COMMAND_HEADER_SIZE          (sizeof(::Barry::Protocol::DBCommand) - sizeof(::Barry::Protocol::DBCommand::Parameters))
 508
 509
 510
 511 ///////////////////////////////////////////////////////////////////////////////
 512 // Protocol response parameter structures
 513
 514 struct DBR_OldDBDBRecord
 515 {
 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))
 520
 521 struct DBR_DBDBRecord
 522 {
 523         uint16_t        count;
 524         uint8_t         unknown[3];
 525         DBDBField       field[1];
 526 } __attribute__ ((packed));
 527 #define DBDB_RECORD_HEADER_SIZE         (sizeof(::Barry::Protocol::DBR_DBDBRecord) - sizeof(::Barry::Protocol::DBDBField))
 528
 529 // Records with a uniqueId.  This covers the following records:
 530 //
 531 //      Old Contact records
 532 //      Old Service Book records
 533 //      Old Calendar records
 534 //
 535 struct DBR_OldTaggedRecord
 536 {
 537         uint8_t         rectype;
 538         uint16_t        index;
 539         uint32_t        uniqueId;
 540         uint8_t         unknown2;
 541
 542         union TaggedData
 543         {
 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))
 548
 549 struct MessageRecord
 550 {
 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
 562
 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)
 567         uint16_t        dateSent;
 568         uint16_t        timeSent;
 569
 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
 583
 584         uint32_t        folderOne;      // these are the 'folders' the message is in
 585         uint32_t        folderTwo;      //
 586
 587         uint16_t        replyMessageFlags;      // 0xfffe on recvd messages
 588                                         // 0x001b on reply
 589                                         // 0x0015 on send
 590                                         // 0x3 pin send
 591                                         // 0x2 on pin recv
 592         uint16_t        field27;        // set to 0x00000004 on PIN reply, 0x00000005 otherwise
 593         uint32_t        headerUID;      // yet another copy of the UID (RecId)
 594
 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))
 605
 606
 607
 608 ///////////////////////////////////////////////////////////////////////////////
 609 // Protocol response structures
 610
 611 struct DBResponse
 612 {
 613         uint8_t         operation;
 614
 615         union Parameters
 616         {
 617
 618                 DBR_OldTaggedRecord     tagged;
 619                 DBR_OldDBDBRecord       old_dbdb;
 620                 DBR_DBDBRecord          dbdb;
 621
 622         } __attribute__ ((packed)) u;
 623
 624 } __attribute__ ((packed));
 625 #define DB_RESPONSE_HEADER_SIZE         (sizeof(::Barry::Protocol::DBResponse) - sizeof(::Barry::Protocol::DBResponse::Parameters))
 626
 627
 628
 629 ///////////////////////////////////////////////////////////////////////////////
 630 // Database access command structure
 631
 632 // even fragmented packets have a tableCmd
 633 struct DBAccess
 634 {
 635         uint8_t         tableCmd;
 636
 637         union DBData
 638         {
 639                 DBCommand               command;
 640                 DBResponse              response;
 641                 CommandTableField       table[1];
 642                 uint8_t                 return_code;
 643                 uint8_t                 fragment[1];
 644
 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)
 649
 650
 651
 652 ///////////////////////////////////////////////////////////////////////////////
 653 // Javaloader protocol structure
 654
 655 struct JLDirEntry
 656 {
 657         uint16_t        unknown;
 658         uint32_t        timestamp;
 659         uint16_t        filename_size;
 660         uint8_t         filename[1];
 661         // the rest of the packet is variable length
 662         // another string for version, then:
 663         // uint32_t     cod_size;
 664
 665 } __attribute__ ((packed));
 666 #define SB_JLDIRENTRY_HEADER_SIZE               (sizeof(::Barry::Protocol::JLDirEntry) - 1)
 667
 668 struct JLCommand
 669 {
 670         uint8_t         command;
 671         uint8_t         unknown;        // nearly always 0, might be top half of command
 672         uint16_t        size;
 673 } __attribute__ ((packed));
 674 #define SB_JLCOMMAND_HEADER_SIZE                (sizeof(::Barry::Protocol::JLCommand))
 675
 676 struct JLResponse
 677 {
 678         uint8_t         command;
 679         uint8_t         unknown;
 680         uint16_t        expect;
 681 } __attribute__ ((packed));
 682 #define SB_JLRESPONSE_HEADER_SIZE               (sizeof(::Barry::Protocol::JLResponse))
 683
 684 struct JLScreenInfo
 685 {
 686         uint16_t        unknown1;
 687         uint16_t        unknown2;
 688         uint16_t        unknown3;
 689         uint16_t        width;
 690         uint16_t        height;
 691         uint16_t        unknown4;
 692         uint16_t        unknown5;
 693         uint16_t        unknown6;
 694 } __attribute__ ((packed));
 695 #define SB_JLSCREENINFO_SIZE                    (sizeof(::Barry::Protocol::JLScreenInfo))
 696
 697 struct JLEventlogEntry
 698 {
 699         uint16_t        size;
 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))
 704
 705 struct JLDeviceInfo
 706 {
 707         uint32_t        hardware_id;
 708         uint32_t        pin;
 709         uint32_t        os_version;
 710         uint32_t        vm_version;
 711         uint32_t        radio_id;
 712         uint32_t        vendor_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
 716         //uint8_t               raw[4];
 717 } __attribute__ ((packed));
 718 #define SB_JLDEVICEINFO_SIZE                    (sizeof(::Barry::Protocol::JLDeviceInfo))
 719
 720 struct JLPacket
 721 {
 722         uint16_t        socket;
 723         uint16_t        size;           // total size of data packet
 724
 725         union PacketData
 726         {
 727                 JLCommand               command;
 728                 JLResponse              response;
 729                 JLScreenInfo            screeninfo;
 730                 JLEventlogEntry         logentry;
 731                 JLDeviceInfo            devinfo;
 732                 uint8_t                 raw[1];
 733                 char                    filename[1];
 734                 uint32_t                cod_size;
 735                 uint32_t                timestamp;
 736                 uint16_t                id;
 737         } __attribute__ ((packed)) u;
 738
 739 } __attribute__ ((packed));
 740 #define SB_JLPACKET_HEADER_SIZE         (sizeof(::Barry::Protocol::JLPacket) - sizeof(::Barry::Protocol::JLPacket::PacketData))
 741
 742
 743 ///////////////////////////////////////////////////////////////////////////////
 744 // JavaDebug protocol structures
 745
 746 namespace JDWP {
 747
 748         // Packet command
 749         //----------------
 750
 751         struct PacketEventRequestSet {
 752                 uint8_t eventKind;
 753                 uint8_t suspendPolicy;
 754                 uint32_t modifiers;
 755         } __attribute__ ((packed));
 756
 757
 758         struct PacketEventRequest {
 759                 union PacketEventRequestData {
 760                         PacketEventRequestSet set;
 761                 } __attribute__ ((packed)) u;
 762         } __attribute__ ((packed));
 763
 764
 765         struct PacketCommand {
 766                 uint8_t commandset;
 767                 uint8_t command;
 768
 769                 union PacketCommandData {
 770                         PacketEventRequest eventRequest;
 771                 } __attribute__ ((packed)) u;
 772         } __attribute__ ((packed));
 773         #define JDWP_COMMAND_HEADER_SIZE                        (sizeof(::Barry::Protocol::JDWP::PacketCommand))
 774
 775
 776         // Packet response
 777         //-----------------
 778
 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));
 786
 787         #define JDWP_PACKETVIRTUALMACHINEIDSIZES_DATA_SIZE              sizeof(::Barry::Protocol::JDWP::PacketVirtualMachineIDSizes)
 788
 789
 790         struct PacketVirtualMachine {
 791                 union PacketVirtualMachineData {
 792                         PacketVirtualMachineIDSizes IDSizes;
 793                 } __attribute__ ((packed)) u;
 794         } __attribute__ ((packed));
 795
 796
 797         struct PacketResponse {
 798                 uint16_t errorcode;
 799
 800                 union PacketResponseData {
 801                         PacketVirtualMachine virtualMachine;
 802                         uint32_t value;
 803                         uint8_t raw[1];
 804                 } __attribute__ ((packed)) u;
 805         } __attribute__ ((packed));
 806         #define JDWP_RESPONSE_HEADER_SIZE                       (sizeof(::Barry::Protocol::JDWP::PacketResponse) - sizeof(::Barry::Protocol::JDWP::PacketResponse::PacketResponseData))
 807
 808
 809         // Generic packet
 810         //----------------
 811
 812         struct Packet {
 813                 uint32_t length;
 814                 uint32_t id;
 815                 uint8_t flags;
 816
 817                 union PacketType {
 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))
 823
 824
 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
 827
 828
 829 } // namespace JDWP
 830
 831 struct JDWField {
 832         uint32_t size;
 833
 834         union JDWFieldData {
 835                 uint8_t raw[1];
 836         } __attribute__ ((packed)) u;
 837 } __attribute__ ((packed));
 838 #define JDWP_FIELD_HEADER_SIZE                  (sizeof(::Barry::Protocol::JDWField) - sizeof(::Barry::Protocol::JDWField::JDWFieldData))
 839
 840 struct JVMCommand
 841 {
 842         uint16_t        size;
 843         uint8_t         command;
 844         uint8_t         raw[1];
 845 } __attribute__ ((packed));
 846 #define SB_JVMCOMMAND_HEADER_SIZE               (sizeof(::Barry::Protocol::JVMCommand))
 847
 848 struct JVMResponse
 849 {
 850         uint8_t         command;
 851         uint8_t         unknown;
 852         uint16_t        expect;
 853 } __attribute__ ((packed));
 854 #define SB_JVMRESPONSE_HEADER_SIZE              (sizeof(::Barry::Protocol::JVMResponse))
 855
 856 struct JVMModulesList
 857 {
 858         uint32_t        nbr;
 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))
 863
 864 struct JVMModulesEntry
 865 {
 866         uint32_t        id;
 867         uint32_t        uniqueId;
 868         uint16_t        sizename;
 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))
 873
 874 struct JVMThreadsList
 875 {
 876         uint32_t        nbr;
 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))
 881
 882 struct JVMUnknown01
 883 {
 884         uint8_t         byte;
 885         uint32_t        address;
 886 } __attribute__ ((packed));
 887 #define SB_JVMUNKNOWN01_HEADER_SIZE                     (sizeof(::Barry::Protocol::JVMUnknown01))
 888
 889 struct JVMUnknown02
 890 {
 891         uint32_t        address1;
 892         uint32_t        address2;
 893 } __attribute__ ((packed));
 894 #define SB_JVMUNKNOWN02_HEADER_SIZE                     (sizeof(::Barry::Protocol::JVMUnknown02))
 895
 896 struct JVMPacket
 897 {
 898         uint16_t        socket;
 899         uint16_t        size;           // total size of data packet
 900
 901         union PacketData
 902         {
 903                 JVMCommand              command;
 904                 JVMResponse             response;
 905                 JVMModulesList          moduleslist;
 906                 JVMThreadsList          threadslist;
 907                 JVMUnknown01            unknown01;
 908                 JVMUnknown02            unknown02;
 909                 uint32_t                address;
 910                 uint16_t                expect;
 911                 uint16_t                msglength;
 912                 uint16_t                value;
 913                 uint8_t                 status;
 914                 uint8_t                 raw[1];
 915         } __attribute__ ((packed)) u;
 916
 917 } __attribute__ ((packed));
 918 #define SB_JVMPACKET_HEADER_SIZE                (sizeof(::Barry::Protocol::JVMPacket) - sizeof(::Barry::Protocol::JVMPacket::PacketData))
 919
 920
 921 /////////////////////////////////////////////////////////////////////////////
 922 // Raw channel packet structure
 923 struct ChannelPacket
 924 {
 925         uint16_t        socket;         // socket ID... 0 exists by default
 926         uint16_t        size;           // total size of data packet
 927
 928         union PacketData
 929         {
 930                 uint8_t                 data[1];
 931         } __attribute__ ((packed)) u;
 932 } __attribute__ ((packed));
 933 #define SB_CHANNELPACKET_HEADER_SIZE            (sizeof(::Barry::Protocol::ChannelPacket) - sizeof(::Barry::Protocol::ChannelPacket::PacketData))
 934
 935 #define SB_CHANNELPACKET_MAX_DATA_SIZE          0x3FFC
 936
 937 ///////////////////////////////////////////////////////////////////////////////
 938 // Main packet struct
 939
 940 struct Packet
 941 {
 942         uint16_t        socket;         // socket ID... 0 exists by default
 943         uint16_t        size;           // total size of data packet
 944         uint8_t         command;
 945
 946         union PacketData
 947         {
 948
 949                 SocketCommand           socket;
 950                 SequenceCommand         sequence;
 951                 DBAccess                db;
 952                 uint8_t                 raw[1];
 953
 954         } __attribute__ ((packed)) u;
 955 } __attribute__ ((packed));
 956 #define SB_PACKET_SOCKET_SIZE                   (sizeof(uint16_t)) // size needed to read the socket in a packet
 957 #define SB_PACKET_HEADER_SIZE                   (sizeof(::Barry::Protocol::Packet) - sizeof(::Barry::Protocol::Packet::PacketData))
 958
 959 // WARNING : For JavaLoader we have some packet with 5 size !
 960 #define MIN_PACKET_SIZE                 5
 961 #define MIN_PACKET_DATA_SIZE            4
 962
 963
 964 // maximum sizes
 965 #define MAX_PACKET_SIZE                 0x400   // anything beyond this needs to be fragmented
 966 #define MAX_PACKET_DATA_SIZE            0x7FC   // for data packet (JavaLoader)
 967
 968 /////////////////////////////////////////////////////////////////////////////
 969 //
 970 // various useful sizes
 971 //
 972
 973 #define SB_PACKET_DBACCESS_HEADER_SIZE          (SB_PACKET_HEADER_SIZE + SB_DBACCESS_HEADER_SIZE)
 974 #define SB_FRAG_HEADER_SIZE                     SB_PACKET_DBACCESS_HEADER_SIZE
 975
 976 #define SB_PACKET_COMMAND_HEADER_SIZE           (SB_PACKET_DBACCESS_HEADER_SIZE + DB_COMMAND_HEADER_SIZE)
 977 #define SB_PACKET_RESPONSE_HEADER_SIZE          (SB_PACKET_DBACCESS_HEADER_SIZE + DB_RESPONSE_HEADER_SIZE)
 978
 979 #define SB_PACKET_DBDB_HEADER_SIZE              (SB_PACKET_RESPONSE_HEADER_SIZE + DBDB_RECORD_HEADER_SIZE)
 980 #define SB_PACKET_OLD_DBDB_HEADER_SIZE          (SB_PACKET_RESPONSE_HEADER_SIZE + OLD_DBDB_RECORD_HEADER_SIZE)
 981
 982 #define SB_PACKET_UPLOAD_HEADER_SIZE            (SB_PACKET_DBACCESS_HEADER_SIZE + UPLOAD_HEADER_SIZE)
 983
 984 #define SB_SEQUENCE_PACKET_SIZE                 (SB_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::SequenceCommand))
 985 #define SB_SOCKET_PACKET_HEADER_SIZE            (SB_PACKET_HEADER_SIZE + SOCKET_COMMAND_HEADER_SIZE)
 986 #define SB_MODE_PACKET_COMMAND_SIZE             (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::ModeSelect) - sizeof(::Barry::Protocol::ModeSelect::ResponseBlock))
 987 #define SB_MODE_PACKET_RESPONSE_SIZE            (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(::Barry::Protocol::ModeSelect))
 988
 989
 990 // Macros
 991 #define COMMAND(data)                           (((const ::Barry::Protocol::Packet *)data.GetData())->command)
 992 #define IS_COMMAND(data, cmd)                   (COMMAND(data) == cmd)
 993 #define MAKE_PACKET(var, data)                  const ::Barry::Protocol::Packet *var = (const ::Barry::Protocol::Packet *) (data).GetData()
 994 #define MAKE_JLPACKET(var, data)                const ::Barry::Protocol::JLPacket *var = (const ::Barry::Protocol::JLPacket *) (data).GetData()
 995 #define MAKE_JVMPACKET(var, data)               const ::Barry::Protocol::JVMPacket *var = (const ::Barry::Protocol::JVMPacket *) (data).GetData()
 996 #define MAKE_CHANNELPACKET(var, data)           const ::Barry::Protocol::ChannelPacket *var = (const ::Barry::Protocol::ChannelPacket *) (data).GetData()
 997 #define MAKE_PACKETPTR_BUF(var, ptr)            ::Barry::Protocol::Packet *var = (::Barry::Protocol::Packet *)ptr
 998 #define MAKE_JLPACKETPTR_BUF(var, ptr)          ::Barry::Protocol::JLPacket *var = (::Barry::Protocol::JLPacket *)ptr
 999 #define MAKE_JVMPACKETPTR_BUF(var, ptr)         ::Barry::Protocol::JVMPacket *var = (::Barry::Protocol::JVMPacket *)ptr
1000 #define MAKE_CHANNELPACKETPTR_BUF(var, ptr)     ::Barry::Protocol::ChannelPacket *var = (::Barry::Protocol::ChannelPacket *)ptr
1001 #define MAKE_RECORD(type,var,data,off)          type *var = (type *) ((data).GetData() + (off))
1002 #define MAKE_RECORD_PTR(type,var,data,off)      type *var = (type *) ((data) + (off))
1003
1004 // fragmentation protocol
1005 // send DATA first, then keep sending DATA packets, FRAGMENTing
1006 // as required until finished, then send DONE.  Both sides behave
1007 // this way, so different sized data can be sent in both
1008 // directions
1009 //
1010 // the fragmented piece only has a the param header, and then continues
1011 // right on with the data
1012
1013
1014
1015 // checks packet size and throws BError if not right
1016 void CheckSize(const Barry::Data &packet, size_t requiredsize);
1017 unsigned int GetSize(const Barry::Data &packet);
1018
1019 }} // namespace Barry::Protocol
1020
1021 #endif
1022