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                 uint32_t        uint32;
 114                 int32_t         min1900;
 115                 uint16_t        code;
 116                 uint8_t         raw[1];
 117                 int16_t         int16;
 118
 119         } __attribute__ ((packed)) u;
 120
 121 } __attribute__ ((packed));
 122 #define COMMON_FIELD_HEADER_SIZE        (sizeof(Barry::Protocol::CommonField) - sizeof(Barry::Protocol::CommonField::CommonFieldData))
 123 #define COMMON_FIELD_MIN1900_SIZE       (sizeof(int32_t))
 124
 125 struct CommandTableField
 126 {
 127         uint8_t         size;           // no null terminator
 128         uint8_t         code;
 129         uint8_t         name[1];
 130 } __attribute__ ((packed));
 131 #define COMMAND_FIELD_HEADER_SIZE       (sizeof(Barry::Protocol::CommandTableField) - 1)
 132
 133 struct OldDBDBField
 134 {
 135         uint16_t        dbNumber;
 136         uint8_t         unknown1;
 137         uint32_t        dbSize;                 // assumed from Cassis docs...
 138                                                 // always 0 in USB
 139         uint16_t        dbRecordCount;
 140         uint16_t        unknown2;
 141         uint16_t        nameSize;               // includes null terminator
 142         uint8_t         name[1];
 143 } __attribute__ ((packed));
 144 #define OLD_DBDB_FIELD_HEADER_SIZE      (sizeof(Barry::Protocol::OldDBDBField) - 1)
 145
 146 struct DBDBField
 147 {
 148         uint16_t        dbNumber;
 149         uint8_t         unknown1;
 150         uint32_t        dbSize;                 // assumed from Cassis docs...
 151                                                 // always 0 in USB
 152         uint32_t        dbRecordCount;
 153         uint16_t        unknown2;
 154         uint16_t        nameSize;               // includes null terminator
 155         uint8_t         unknown3;
 156         uint8_t         name[1];                // followed by 2 zeros!
 157         uint16_t        unknown;                // this comes after the
 158                                                 // null terminated name, but
 159                                                 // is here for size calcs
 160 } __attribute__ ((packed));
 161 #define DBDB_FIELD_HEADER_SIZE  (sizeof(Barry::Protocol::DBDBField) - 1)
 162
 163 struct RecordStateTableField
 164 {
 165         uint8_t         rectype;                // it is unknown exactly what
 166                                                 // this field does, but it
 167                                                 // shows up here and in the
 168                                                 // tagged record header, and
 169                                                 // for some of the records
 170                                                 // they must match when writing
 171         uint16_t        index;
 172         uint32_t        uniqueId;               // matches the uniqueId of say,
 173                                                 // address book records
 174         uint8_t         flags;                  // bit 0x01 is the dirty flag
 175                                                 // don't know if any other bits
 176                                                 // are used
 177 #define BARRY_RSTF_DIRTY        0x01
 178         uint8_t         unknown2[4];
 179 } __attribute__ ((packed));
 180
 181 struct CalendarRecurrenceDataField  // as documented in the Cassis project spec
 182 {
 183         uint8_t         type;
 184 #define CRDF_TYPE_DAY           0x01
 185 #define CRDF_TYPE_MONTH_BY_DATE 0x03
 186 #define CRDF_TYPE_MONTH_BY_DAY  0x04
 187 #define CRDF_TYPE_YEAR_BY_DATE  0x05
 188 #define CRDF_TYPE_YEAR_BY_DAY   0x06
 189 #define CRDF_TYPE_WEEK          0x0c
 190
 191         uint8_t         unknown;                // always 0x01
 192         uint16_t        interval;
 193         uint32_t        startTime;
 194         uint32_t        endTime;                // 0xFFFFFFFF for never
 195
 196         union Additional
 197         {
 198                 // Note: blank fields should be set to 0
 199
 200                 struct Day
 201                 {
 202                         uint8_t day[6];         // always zeros!
 203                 } __attribute__ ((packed)) day;
 204
 205                 struct MonthByDate
 206                 {
 207                         uint8_t monthDay;       // day of month to recur on
 208                                                 // (1-31)
 209                         uint8_t blank[5];
 210                 } __attribute__ ((packed)) month_by_date;
 211
 212                 struct MonthByDay
 213                 {
 214                         uint8_t weekDay;        // day of week to recur on (0-6)
 215                         uint8_t week;           // week of month to recur on
 216                                                 // (1 to 5, first week, second
 217                                                 // week, etc)
 218                         uint8_t blank[4];
 219                 } __attribute__ ((packed)) month_by_day;
 220
 221                 struct YearByDate
 222                 {
 223                         uint8_t monthDay;       // day of month to recur on
 224                                                 // (1-31)
 225                         uint8_t blank;
 226                         uint8_t month;          // month to recur on (1-12)
 227                         uint8_t blank_[3];
 228                 } __attribute__ ((packed)) year_by_date;
 229
 230                 struct YearByDay
 231                 {
 232                         uint8_t weekDay;        // day of week to recur on (0-6)
 233                         uint8_t week;           // week of month (1 to 5)
 234                         uint8_t month;          // (1-12)
 235                         uint8_t blank[3];
 236                 } __attribute__ ((packed)) year_by_day;
 237
 238                 struct Week
 239                 {
 240                         uint8_t days;           // bitmask
 241                         #define CRDF_WD_SUN     0x01
 242                         #define CRDF_WD_MON     0x02
 243                         #define CRDF_WD_TUE     0x04
 244                         #define CRDF_WD_WED     0x08
 245                         #define CRDF_WD_THU     0x10
 246                         #define CRDF_WD_FRI     0x20
 247                         #define CRDF_WD_SAT     0x40
 248
 249                         uint8_t blank[5];
 250                 } __attribute__ ((packed)) week;
 251
 252         } __attribute__ ((packed)) u;
 253
 254 } __attribute__ ((packed));
 255 #define CALENDAR_RECURRENCE_DATA_FIELD_SIZE     sizeof(Barry::Protocol::CalendarRecurrenceDataField)
 256
 257 //
 258 // Calendar record: field constants
 259 //
 260
 261 #define CR_FREEBUSY_FREE                0
 262 #define CR_FREEBUSY_TENTATIVE           1
 263 #define CR_FREEBUSY_BUSY                2
 264 #define CR_FREEBUSY_OUT_OF_OFFICE       3
 265 #define CR_FREEBUSY_RANGE_LOW           0
 266 #define CR_FREEBUSY_RANGE_HIGH          3
 267
 268 #define CR_CLASS_PUBLIC                 0
 269 #define CR_CLASS_CONFIDENTIAL           1
 270 #define CR_CLASS_PRIVATE                2
 271 #define CR_CLASS_RANGE_LOW              0
 272 #define CR_CLASS_RANGE_HIGH             2
 273
 274
 275 //
 276 // Task record: field constants
 277 //
 278
 279 #define TR_ALARM_DATE                   1
 280 #define TR_ALARM_RELATIVE               2
 281 #define TR_ALARM_RANGE_LOW              1
 282 #define TR_ALARM_RANGE_HIGH             2
 283
 284 #define TR_PRIORITY_HIGH                0
 285 #define TR_PRIORITY_NORMAL              1
 286 #define TR_PRIORITY_LOW                 2
 287 #define TR_PRIORITY_RANGE_LOW           0
 288 #define TR_PRIORITY_RANGE_HIGH          2
 289
 290 #define TR_STATUS_NOT_STARTED           0
 291 #define TR_STATUS_IN_PROGRESS           1
 292 #define TR_STATUS_COMPLETED             2
 293 #define TR_STATUS_WAITING               3
 294 #define TR_STATUS_DEFERRED              4
 295 #define TR_STATUS_RANGE_LOW             0
 296 #define TR_STATUS_RANGE_HIGH            4
 297
 298 //
 299 // Phone Call Logs record: field constants
 300 //
 301 //
 302 #define CLL_DIRECTION_RECEIVER          0
 303 #define CLL_DIRECTION_EMITTER           1
 304 #define CLL_DIRECTION_FAILED            2
 305 #define CLL_DIRECTION_MISSING           3
 306 #define CLL_DIRECTION_RANGE_LOW         0
 307 #define CLL_DIRECTION_RANGE_HIGH        3
 308
 309 #define CLL_PHONETYPE_UNDEFINED         0
 310 #define CLL_PHONETYPE_OFFICE            1
 311 #define CLL_PHONETYPE_HOME                      2
 312 #define CLL_PHONETYPE_MOBILE            3
 313 #define CLL_PHONETYPE_RANGE_LOW         0
 314 #define CLL_PHONETYPE_RANGE_HIGH        3
 315
 316 //
 317 // Folder record: field constants
 318 //
 319
 320 #define FR_TYPE_SUBTREE                 0x00
 321 #define FR_TYPE_DELETED                 0x01
 322 #define FR_TYPE_INBOX                   0x02
 323 #define FR_TYPE_OUTBOX                  0x03
 324 #define FR_TYPE_SENT                    0x04
 325 #define FR_TYPE_OTHER                   0x05
 326 #define FR_TYPE_DRAFT                   0x0a
 327
 328 #define FR_STATUS_ORPHAN                0x50
 329 #define FR_STATUS_UNFILED               0x51
 330 #define FR_STATUS_FILED                 0x52
 331
 332
 333 ///////////////////////////////////////////////////////////////////////////////
 334 // Packed field structures - odd format used with Service Book records
 335
 336 struct PackedField_02
 337 {
 338         uint8_t         code;
 339         uint8_t         size;
 340         uint8_t         type;
 341         uint8_t         raw[1];
 342 } __attribute__ ((packed));
 343 #define PACKED_FIELD_02_HEADER_SIZE     (sizeof(Barry::Protocol::PackedField_02) - 1)
 344
 345 struct PackedField_10
 346 {
 347         uint8_t         type;
 348         uint8_t         size;
 349         uint8_t         raw[1];
 350 } __attribute__ ((packed));
 351 #define PACKED_FIELD_10_HEADER_SIZE     (sizeof(Barry::Protocol::PackedField_10) - 1)
 352
 353
 354
 355
 356 ///////////////////////////////////////////////////////////////////////////////
 357 // Service Book field and record structures
 358
 359 struct ServiceBookConfigField
 360 {
 361         uint8_t         format;
 362         uint8_t         fields[1];
 363 } __attribute__ ((packed));
 364 #define SERVICE_BOOK_CONFIG_FIELD_HEADER_SIZE (sizeof(Barry::Protocol::ServiceBookConfigField) - 1)
 365
 366
 367 ///////////////////////////////////////////////////////////////////////////////
 368 // DB Command Parameter structures
 369
 370 struct DBC_Record
 371 {
 372         uint16_t        recordIndex;    // index comes from RecordStateTable
 373         uint8_t         data[1];
 374 } __attribute__ ((packed));
 375 #define DBC_RECORD_HEADER_SIZE          (sizeof(Barry::Protocol::DBC_Record) - 1)
 376
 377 struct DBC_RecordFlags
 378 {
 379         uint8_t         unknown;
 380         uint16_t        index;
 381         uint8_t         unknown2[5];
 382 } __attribute__ ((packed));
 383 #define DBC_RECORD_FLAGS_SIZE           (sizeof(Barry::Protocol::DBC_RecordFlags))
 384
 385 struct DBC_TaggedUpload
 386 {
 387         uint8_t         rectype;                // it is unknown exactly what
 388                                                 // this field does, but it
 389                                                 // shows up here and in the
 390                                                 // RecordStateTable, and
 391                                                 // for some of the records
 392                                                 // they must match when writing
 393         uint32_t        uniqueId;
 394         uint8_t         unknown2;
 395         uint8_t         data[1];
 396 } __attribute__ ((packed));
 397 #define DBC_TAGGED_UPLOAD_HEADER_SIZE   (sizeof(Barry::Protocol::DBC_TaggedUpload) - 1)
 398
 399 struct DBC_IndexedUpload
 400 {
 401         uint8_t         unknown;        // observed: 00 or 05
 402         uint16_t        index;
 403         uint8_t         data[1];
 404 } __attribute__ ((packed));
 405 #define DBC_INDEXED_UPLOAD_HEADER_SIZE  (sizeof(Barry::Protocol::DBC_IndexedUpload) - 1)
 406
 407 struct PasswordChallenge
 408 {
 409         uint8_t         remaining_tries;        // number of password attempts
 410                                                 // the device will accept before
 411                                                 // committing suicide...
 412                                                 // starts at 10 and counts down
 413                                                 // on each bad password
 414         uint8_t         unknown;                // observed as 0... probably just
 415                                                 // the top byte of a uint16
 416                                                 // remaining_tries, but I don't
 417                                                 // want to take that chance
 418         uint16_t        param;                  // seems to be a secondary command
 419                                                 // of some kind, observed as 0x14
 420                                                 // or 0x04, but purpose unknown
 421                                                 // possibly a send/receive flag
 422                                                 // bit (0x10/0x00)
 423         union Hash
 424         {
 425                 uint32_t        seed;
 426                 uint8_t         hash[20];
 427         } __attribute__ ((packed)) u;
 428
 429 } __attribute__ ((packed));
 430 #define PASSWORD_CHALLENGE_HEADER_SIZE  (sizeof(Barry::Protocol::PasswordChallenge) - sizeof(Barry::Protocol::PasswordChallenge::Hash))
 431 #define PASSWORD_CHALLENGE_SEED_SIZE    (PASSWORD_CHALLENGE_HEADER_SIZE + sizeof(uint32_t))
 432 #define PASSWORD_CHALLENGE_SIZE         (sizeof(Barry::Protocol::PasswordChallenge))
 433
 434 struct AttributeFetch
 435 {
 436         uint16_t        object;
 437         uint16_t        attribute;
 438         uint8_t         raw[1];                 // used only in response
 439 } __attribute__ ((packed));
 440 #define ATTRIBUTE_FETCH_COMMAND_SIZE    (sizeof(Barry::Protocol::AttributeFetch) - 1)
 441
 442 struct ModeSelect
 443 {
 444         uint8_t         name[16];
 445         struct ResponseBlock
 446         {
 447                 uint8_t         unknown[20];
 448         } __attribute__ ((packed)) response;
 449 } __attribute__ ((packed));
 450
 451 struct Echo
 452 {
 453         uint64_t        ticks;                  // number of microseconds since
 454                                                 // host system startup
 455 } __attribute__ ((packed));
 456 #define ECHO_COMMAND_SIZE               (sizeof(Barry::Protocol::Echo))
 457
 458
 459 ///////////////////////////////////////////////////////////////////////////////
 460 // Protocol command structures
 461
 462 struct SocketCommand
 463 {
 464         uint16_t        socket;
 465         uint8_t         sequence;               // incremented on each socket 0
 466                                                 // communication, replies return
 467                                                 // the same number from command
 468
 469         union PacketData
 470         {
 471
 472                 PasswordChallenge       password;
 473                 AttributeFetch          fetch;
 474                 ModeSelect              mode;
 475                 uint8_t                 raw[1];
 476                 Echo                    echo;
 477
 478         } __attribute__ ((packed)) u;
 479 } __attribute__ ((packed));
 480 #define SOCKET_COMMAND_HEADER_SIZE              (sizeof(Barry::Protocol::SocketCommand) - sizeof(Barry::Protocol::SocketCommand::PacketData))
 481
 482 struct SequenceCommand
 483 {
 484         uint8_t         unknown1;
 485         uint8_t         unknown2;
 486         uint8_t         unknown3;
 487         uint32_t        sequenceId;
 488 } __attribute__ ((packed));
 489
 490 struct DBCommand
 491 {
 492         uint8_t         operation;      // see below
 493         uint16_t        databaseId;     // value from the Database Database
 494
 495         union Parameters
 496         {
 497
 498                 DBC_Record              record;
 499                 DBC_RecordFlags         flags;
 500                 DBC_TaggedUpload        tag_upload;
 501                 DBC_IndexedUpload       index_upload;
 502                 uint8_t                 raw[1];
 503
 504         } __attribute__ ((packed)) u;
 505 } __attribute__ ((packed));
 506 #define DB_COMMAND_HEADER_SIZE          (sizeof(Barry::Protocol::DBCommand) - sizeof(Barry::Protocol::DBCommand::Parameters))
 507
 508
 509
 510 ///////////////////////////////////////////////////////////////////////////////
 511 // Protocol response parameter structures
 512
 513 struct DBR_OldDBDBRecord
 514 {
 515         uint16_t        count;                  // number of fields in record
 516         OldDBDBField    field[1];
 517 } __attribute__ ((packed));
 518 #define OLD_DBDB_RECORD_HEADER_SIZE     (sizeof(Barry::Protocol::DBR_OldDBDBRecord) - sizeof(Barry::Protocol::OldDBDBField))
 519
 520 struct DBR_DBDBRecord
 521 {
 522         uint16_t        count;
 523         uint8_t         unknown[3];
 524         DBDBField       field[1];
 525 } __attribute__ ((packed));
 526 #define DBDB_RECORD_HEADER_SIZE         (sizeof(Barry::Protocol::DBR_DBDBRecord) - sizeof(Barry::Protocol::DBDBField))
 527
 528 // Records with a uniqueId.  This covers the following records:
 529 //
 530 //      Old Contact records
 531 //      Old Service Book records
 532 //      Old Calendar records
 533 //
 534 struct DBR_OldTaggedRecord
 535 {
 536         uint8_t         rectype;
 537         uint16_t        index;
 538         uint32_t        uniqueId;
 539         uint8_t         unknown2;
 540
 541         union TaggedData
 542         {
 543                 CommonField     field[1];
 544         } __attribute__ ((packed)) u;
 545 } __attribute__ ((packed));
 546 #define DBR_OLD_TAGGED_RECORD_HEADER_SIZE (sizeof(Barry::Protocol::DBR_OldTaggedRecord) - sizeof(Barry::Protocol::DBR_OldTaggedRecord::TaggedData))
 547
 548 struct MessageRecord
 549 {
 550         uint8_t         field1;         // always 'j'
 551         uint32_t        field2;         // always 0x00000000
 552         uint32_t        flags;          // flags
 553         uint32_t        field4;         // normal email and pin recv this is 0x7ff
 554                                         // changes on sent and reply to 0x01ffffff
 555                                         // and 0x003fffff on pin send
 556         uint32_t        field5;         // always 0x00000000
 557         uint32_t        field6;         // always 0x00000000
 558         uint32_t        field7;         // always 0x00000000
 559         uint32_t        field8;         // always 0x00000000
 560         uint16_t        field9;         // always 0x0000
 561
 562         uint16_t        dateReceived;   // the first two of these time fields are always the same
 563         uint16_t        timeReceived;   //
 564         uint16_t        dateDuplicate;  // On mail sent from the BB all three fields are identical
 565         uint16_t        timeDuplicate;  // (time sent)
 566         uint16_t        dateSent;
 567         uint16_t        timeSent;
 568
 569         uint16_t        priority;       // priority field
 570         uint32_t        field14;        // always 0x00000000
 571         uint32_t        field15;        // always 0x00000000
 572         uint16_t        field16;        // always 0x0000
 573         uint32_t        field13;        // PIN reply 0x00000000 other time 0xffffffff or 0xfffffffe
 574         uint16_t        messageSize;    // Message size, 0x0000 if Reply or Saved, 0xffff if below ????
 575         uint32_t        field18;        // 0x0's and 0xF'x
 576         uint32_t        field19;        // 0x0's and 0xF's
 577         uint16_t        field20;        // always 0x0000
 578         uint16_t        field21;        // 0x01 unless PIN reply then 0x00
 579         uint32_t        inReplyTo;      // reply to message?
 580         uint32_t        field22;        // always 0x00000000
 581         uint16_t        field23;        // FIXME
 582
 583         uint32_t        folderOne;      // these are the 'folders' the message is in
 584         uint32_t        folderTwo;      //
 585
 586         uint16_t        replyMessageFlags;      // 0xfffe on recvd messages
 587                                         // 0x001b on reply
 588                                         // 0x0015 on send
 589                                         // 0x3 pin send
 590                                         // 0x2 on pin recv
 591         uint16_t        field27;        // set to 0x00000004 on PIN reply, 0x00000005 otherwise
 592         uint32_t        headerUID;      // yet another copy of the UID (RecId)
 593
 594         uint32_t        field29;        // always 0x00000000
 595         uint16_t        field30;        // always 0x0002
 596         uint16_t        field31;        // always 0x00000000
 597         uint16_t        field32;        // always 0x0004
 598         uint16_t        field34;        // always 0x0000
 599         uint8_t         field33;        // always 'd'
 600         uint32_t        timeBlock;      // FIXME
 601         CommonField     field[1];
 602 } __attribute__ ((packed));
 603 #define MESSAGE_RECORD_HEADER_SIZE (sizeof(Barry::Protocol::MessageRecord) - sizeof(Barry::Protocol::CommonField))
 604
 605
 606
 607 ///////////////////////////////////////////////////////////////////////////////
 608 // Protocol response structures
 609
 610 struct DBResponse
 611 {
 612         uint8_t         operation;
 613
 614         union Parameters
 615         {
 616
 617                 DBR_OldTaggedRecord     tagged;
 618                 DBR_OldDBDBRecord       old_dbdb;
 619                 DBR_DBDBRecord          dbdb;
 620
 621         } __attribute__ ((packed)) u;
 622
 623 } __attribute__ ((packed));
 624 #define DB_RESPONSE_HEADER_SIZE         (sizeof(Barry::Protocol::DBResponse) - sizeof(Barry::Protocol::DBResponse::Parameters))
 625
 626
 627
 628 ///////////////////////////////////////////////////////////////////////////////
 629 // Database access command structure
 630
 631 // even fragmented packets have a tableCmd
 632 struct DBAccess
 633 {
 634         uint8_t         tableCmd;
 635
 636         union DBData
 637         {
 638                 DBCommand               command;
 639                 DBResponse              response;
 640                 CommandTableField       table[1];
 641                 uint8_t                 return_code;
 642                 uint8_t                 fragment[1];
 643
 644         } __attribute__ ((packed)) u;
 645 } __attribute__ ((packed));
 646 #define SB_DBACCESS_HEADER_SIZE                 (sizeof(Barry::Protocol::DBAccess) - sizeof(Barry::Protocol::DBAccess::DBData))
 647 #define SB_DBACCESS_RETURN_CODE_SIZE            (1)
 648
 649
 650
 651 ///////////////////////////////////////////////////////////////////////////////
 652 // Javaloader protocol structure
 653
 654 struct JLDirEntry
 655 {
 656         uint16_t        unknown;
 657         uint32_t        timestamp;
 658         uint16_t        filename_size;
 659         uint8_t         filename[1];
 660         // the rest of the packet is variable length
 661         // another string for version, then:
 662         // uint32_t     cod_size;
 663
 664 } __attribute__ ((packed));
 665 #define SB_JLDIRENTRY_HEADER_SIZE               (sizeof(Barry::Protocol::JLDirEntry) - 1)
 666
 667 struct JLCommand
 668 {
 669         uint8_t         command;
 670         uint8_t         unknown;        // nearly always 0, might be top half of command
 671         uint16_t        size;
 672 } __attribute__ ((packed));
 673 #define SB_JLCOMMAND_HEADER_SIZE                (sizeof(Barry::Protocol::JLCommand))
 674
 675 struct JLResponse
 676 {
 677         uint8_t         command;
 678         uint8_t         unknown;
 679         uint16_t        expect;
 680 } __attribute__ ((packed));
 681 #define SB_JLRESPONSE_HEADER_SIZE               (sizeof(Barry::Protocol::JLResponse))
 682
 683 struct JLScreenInfo
 684 {
 685         uint16_t        unknown1;
 686         uint16_t        unknown2;
 687         uint16_t        unknown3;
 688         uint16_t        width;
 689         uint16_t        height;
 690         uint16_t        unknown4;
 691         uint16_t        unknown5;
 692         uint16_t        unknown6;
 693 } __attribute__ ((packed));
 694 #define SB_JLSCREENINFO_SIZE                    (sizeof(Barry::Protocol::JLScreenInfo))
 695
 696 struct JLEventlogEntry
 697 {
 698         uint16_t        size;
 699         // remainder of packet is variable
 700         // it contains the log data as an ASCII (UTF-8?) string
 701 } __attribute__ ((packed));
 702 #define SB_JLEVENTLOG_ENTRY_HEADER_SIZE         (sizeof(Barry::Protocol::JLEventlogEntry))
 703
 704 struct JLDeviceInfo
 705 {
 706         uint32_t        hardware_id;
 707         uint32_t        pin;
 708         uint32_t        os_version;
 709         uint32_t        vm_version;
 710         uint32_t        radio_id;
 711         uint32_t        vendor_id;
 712         uint32_t        active_wafs;
 713         // older devices (such as 7130) don't this extra data in the
 714         // device info packet and will therefore fail the size check
 715         //uint8_t               raw[4];
 716 } __attribute__ ((packed));
 717 #define SB_JLDEVICEINFO_SIZE                    (sizeof(Barry::Protocol::JLDeviceInfo))
 718
 719 struct JLPacket
 720 {
 721         uint16_t        socket;
 722         uint16_t        size;           // total size of data packet
 723
 724         union PacketData
 725         {
 726                 JLCommand               command;
 727                 JLResponse              response;
 728                 JLScreenInfo            screeninfo;
 729                 JLEventlogEntry         logentry;
 730                 JLDeviceInfo            devinfo;
 731                 uint8_t                 raw[1];
 732                 char                    filename[1];
 733                 uint32_t                cod_size;
 734                 uint32_t                timestamp;
 735                 uint16_t                id;
 736         } __attribute__ ((packed)) u;
 737
 738 } __attribute__ ((packed));
 739 #define SB_JLPACKET_HEADER_SIZE         (sizeof(Barry::Protocol::JLPacket) - sizeof(Barry::Protocol::JLPacket::PacketData))
 740
 741
 742 ///////////////////////////////////////////////////////////////////////////////
 743 // JavaDebug protocol structures
 744
 745 namespace JDWP {
 746
 747         // Packet command
 748         //----------------
 749
 750         struct PacketEventRequestSet {
 751                 uint8_t eventKind;
 752                 uint8_t suspendPolicy;
 753                 uint32_t modifiers;
 754         } __attribute__ ((packed));
 755
 756
 757         struct PacketEventRequest {
 758                 union PacketEventRequestData {
 759                         PacketEventRequestSet set;
 760                 } __attribute__ ((packed)) u;
 761         } __attribute__ ((packed));
 762
 763
 764         struct PacketCommand {
 765                 uint8_t commandset;
 766                 uint8_t command;
 767
 768                 union PacketCommandData {
 769                         PacketEventRequest eventRequest;
 770                 } __attribute__ ((packed)) u;
 771         } __attribute__ ((packed));
 772         #define JDWP_COMMAND_HEADER_SIZE                        (sizeof(Barry::Protocol::JDWP::PacketCommand))
 773
 774
 775         // Packet response
 776         //-----------------
 777
 778         struct PacketVirtualMachineIDSizes {
 779                 uint32_t fieldIDSize;
 780                 uint32_t methodIDSize;
 781                 uint32_t objectIDSize;
 782                 uint32_t referenceTypeIDSize;
 783                 uint32_t frameIDSize;
 784         } __attribute__ ((packed));
 785
 786         #define JDWP_PACKETVIRTUALMACHINEIDSIZES_DATA_SIZE              sizeof(Barry::Protocol::JDWP::PacketVirtualMachineIDSizes)
 787
 788
 789         struct PacketVirtualMachine {
 790                 union PacketVirtualMachineData {
 791                         PacketVirtualMachineIDSizes IDSizes;
 792                 } __attribute__ ((packed)) u;
 793         } __attribute__ ((packed));
 794
 795
 796         struct PacketResponse {
 797                 uint16_t errorcode;
 798
 799                 union PacketResponseData {
 800                         PacketVirtualMachine virtualMachine;
 801                         uint32_t value;
 802                         uint8_t raw[1];
 803                 } __attribute__ ((packed)) u;
 804         } __attribute__ ((packed));
 805         #define JDWP_RESPONSE_HEADER_SIZE                       (sizeof(Barry::Protocol::JDWP::PacketResponse) - sizeof(Barry::Protocol::JDWP::PacketResponse::PacketResponseData))
 806
 807
 808         // Generic packet
 809         //----------------
 810
 811         struct Packet {
 812                 uint32_t length;
 813                 uint32_t id;
 814                 uint8_t flags;
 815
 816                 union PacketType {
 817                         PacketCommand command;
 818                         PacketResponse response;
 819                 } __attribute__ ((packed)) u;
 820         } __attribute__ ((packed));
 821         #define JDWP_PACKET_HEADER_SIZE                 (sizeof(Barry::Protocol::JDWP::Packet) - sizeof(Barry::Protocol::JDWP::Packet::PacketType))
 822
 823
 824         #define MAKE_JDWPPACKET(var, data)              const Barry::Protocol::JDWP::Packet *var = (const Barry::Protocol::JDWP::Packet *) (data).GetData()
 825         #define MAKE_JDWPPACKETPTR_BUF(var, ptr)                Barry::Protocol::JDWP::Packet *var = (Barry::Protocol::JDWP::Packet *)ptr
 826
 827
 828 } // namespace JDWP
 829
 830 struct JDWField {
 831         uint32_t size;
 832
 833         union JDWFieldData {
 834                 uint8_t raw[1];
 835         } __attribute__ ((packed)) u;
 836 } __attribute__ ((packed));
 837 #define JDWP_FIELD_HEADER_SIZE                  (sizeof(Barry::Protocol::JDWField) - sizeof(Barry::Protocol::JDWField::JDWFieldData))
 838
 839 struct JVMCommand
 840 {
 841         uint16_t        size;
 842         uint8_t         command;
 843         uint8_t         raw[1];
 844 } __attribute__ ((packed));
 845 #define SB_JVMCOMMAND_HEADER_SIZE               (sizeof(Barry::Protocol::JVMCommand))
 846
 847 struct JVMResponse
 848 {
 849         uint8_t         command;
 850         uint8_t         unknown;
 851         uint16_t        expect;
 852 } __attribute__ ((packed));
 853 #define SB_JVMRESPONSE_HEADER_SIZE              (sizeof(Barry::Protocol::JVMResponse))
 854
 855 struct JVMModulesList
 856 {
 857         uint32_t        nbr;
 858         // remainder of packet is variable
 859         // it contains the modules list
 860 } __attribute__ ((packed));
 861 #define SB_JVMMODULES_LIST_HEADER_SIZE          (sizeof(Barry::Protocol::JVMModulesList))
 862
 863 struct JVMModulesEntry
 864 {
 865         uint32_t        id;
 866         uint32_t        uniqueId;
 867         uint16_t        sizename;
 868         // remainder of packet is variable
 869         // it contains the module name
 870 } __attribute__ ((packed));
 871 #define SB_JVMMODULES_ENTRY_HEADER_SIZE         (sizeof(Barry::Protocol::JVMModulesEntry))
 872
 873 struct JVMThreadsList
 874 {
 875         uint32_t        nbr;
 876         // remainder of packet is variable
 877         // it contains the threads list
 878 } __attribute__ ((packed));
 879 #define SB_JVMTHREADS_LIST_HEADER_SIZE          (sizeof(Barry::Protocol::JVMThreadsList))
 880
 881 struct JVMUnknown01
 882 {
 883         uint8_t         byte;
 884         uint32_t        address;
 885 } __attribute__ ((packed));
 886 #define SB_JVMUNKNOWN01_HEADER_SIZE                     (sizeof(Barry::Protocol::JVMUnknown01))
 887
 888 struct JVMUnknown02
 889 {
 890         uint32_t        address1;
 891         uint32_t        address2;
 892 } __attribute__ ((packed));
 893 #define SB_JVMUNKNOWN02_HEADER_SIZE                     (sizeof(Barry::Protocol::JVMUnknown02))
 894
 895 struct JVMPacket
 896 {
 897         uint16_t        socket;
 898         uint16_t        size;           // total size of data packet
 899
 900         union PacketData
 901         {
 902                 JVMCommand              command;
 903                 JVMResponse             response;
 904                 JVMModulesList          moduleslist;
 905                 JVMThreadsList          threadslist;
 906                 JVMUnknown01            unknown01;
 907                 JVMUnknown02            unknown02;
 908                 uint32_t                address;
 909                 uint16_t                expect;
 910                 uint16_t                msglength;
 911                 uint16_t                value;
 912                 uint8_t                 status;
 913                 uint8_t                 raw[1];
 914         } __attribute__ ((packed)) u;
 915
 916 } __attribute__ ((packed));
 917 #define SB_JVMPACKET_HEADER_SIZE                (sizeof(Barry::Protocol::JVMPacket) - sizeof(Barry::Protocol::JVMPacket::PacketData))
 918
 919
 920 ///////////////////////////////////////////////////////////////////////////////
 921 // Main packet struct
 922
 923 struct Packet
 924 {
 925         uint16_t        socket;         // socket ID... 0 exists by default
 926         uint16_t        size;           // total size of data packet
 927         uint8_t         command;
 928
 929         union PacketData
 930         {
 931
 932                 SocketCommand           socket;
 933                 SequenceCommand         sequence;
 934                 DBAccess                db;
 935                 uint8_t                 raw[1];
 936
 937         } __attribute__ ((packed)) u;
 938 } __attribute__ ((packed));
 939 #define SB_PACKET_HEADER_SIZE                   (sizeof(Barry::Protocol::Packet) - sizeof(Barry::Protocol::Packet::PacketData))
 940
 941 // WARNING : For JavaLoader we have some packet with 5 size !
 942 #define MIN_PACKET_SIZE                 5
 943 #define MIN_PACKET_DATA_SIZE            4
 944
 945
 946 // maximum sizes
 947 #define MAX_PACKET_SIZE                 0x400   // anything beyond this needs to be fragmented
 948 #define MAX_PACKET_DATA_SIZE            0x7FC   // for data packet (JavaLoader)
 949
 950 /////////////////////////////////////////////////////////////////////////////
 951 //
 952 // various useful sizes
 953 //
 954
 955 #define SB_PACKET_DBACCESS_HEADER_SIZE          (SB_PACKET_HEADER_SIZE + SB_DBACCESS_HEADER_SIZE)
 956 #define SB_FRAG_HEADER_SIZE                     SB_PACKET_DBACCESS_HEADER_SIZE
 957
 958 #define SB_PACKET_COMMAND_HEADER_SIZE           (SB_PACKET_DBACCESS_HEADER_SIZE + DB_COMMAND_HEADER_SIZE)
 959 #define SB_PACKET_RESPONSE_HEADER_SIZE          (SB_PACKET_DBACCESS_HEADER_SIZE + DB_RESPONSE_HEADER_SIZE)
 960
 961 #define SB_PACKET_DBDB_HEADER_SIZE              (SB_PACKET_RESPONSE_HEADER_SIZE + DBDB_RECORD_HEADER_SIZE)
 962 #define SB_PACKET_OLD_DBDB_HEADER_SIZE          (SB_PACKET_RESPONSE_HEADER_SIZE + OLD_DBDB_RECORD_HEADER_SIZE)
 963
 964 #define SB_PACKET_UPLOAD_HEADER_SIZE            (SB_PACKET_DBACCESS_HEADER_SIZE + UPLOAD_HEADER_SIZE)
 965
 966 #define SB_SEQUENCE_PACKET_SIZE                 (SB_PACKET_HEADER_SIZE + sizeof(Barry::Protocol::SequenceCommand))
 967 #define SB_SOCKET_PACKET_HEADER_SIZE            (SB_PACKET_HEADER_SIZE + SOCKET_COMMAND_HEADER_SIZE)
 968 #define SB_MODE_PACKET_COMMAND_SIZE             (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(Barry::Protocol::ModeSelect) - sizeof(Barry::Protocol::ModeSelect::ResponseBlock))
 969 #define SB_MODE_PACKET_RESPONSE_SIZE            (SB_SOCKET_PACKET_HEADER_SIZE + sizeof(Barry::Protocol::ModeSelect))
 970
 971
 972 // Macros
 973 #define COMMAND(data)                           (((const Barry::Protocol::Packet *)data.GetData())->command)
 974 #define IS_COMMAND(data, cmd)                   (COMMAND(data) == cmd)
 975 #define MAKE_PACKET(var, data)                  const Barry::Protocol::Packet *var = (const Barry::Protocol::Packet *) (data).GetData()
 976 #define MAKE_JLPACKET(var, data)                const Barry::Protocol::JLPacket *var = (const Barry::Protocol::JLPacket *) (data).GetData()
 977 #define MAKE_JVMPACKET(var, data)               const Barry::Protocol::JVMPacket *var = (const Barry::Protocol::JVMPacket *) (data).GetData()
 978 #define MAKE_PACKETPTR_BUF(var, ptr)            Barry::Protocol::Packet *var = (Barry::Protocol::Packet *)ptr
 979 #define MAKE_JLPACKETPTR_BUF(var, ptr)          Barry::Protocol::JLPacket *var = (Barry::Protocol::JLPacket *)ptr
 980 #define MAKE_JVMPACKETPTR_BUF(var, ptr)         Barry::Protocol::JVMPacket *var = (Barry::Protocol::JVMPacket *)ptr
 981 #define MAKE_RECORD(type,var,data,off)          type *var = (type *) ((data).GetData() + (off))
 982 #define MAKE_RECORD_PTR(type,var,data,off)      type *var = (type *) ((data) + (off))
 983
 984 // fragmentation protocol
 985 // send DATA first, then keep sending DATA packets, FRAGMENTing
 986 // as required until finished, then send DONE.  Both sides behave
 987 // this way, so different sized data can be sent in both
 988 // directions
 989 //
 990 // the fragmented piece only has a the param header, and then continues
 991 // right on with the data
 992
 993
 994
 995 // checks packet size and throws BError if not right
 996 void CheckSize(const Barry::Data &packet, size_t requiredsize);
 997 unsigned int GetSize(const Barry::Data &packet);
 998
 999 }} // namespace Barry::Protocol
1000
1001 #endif
1002