2435 lines
73 KiB
C
2435 lines
73 KiB
C
/******************************************************************************
|
|
*
|
|
* Copyright (c) 1995-1999 Palm Computing, Inc. or its subsidiaries.
|
|
* All rights reserved.
|
|
*
|
|
* File: DLCommon.h
|
|
*
|
|
* Description:
|
|
* Desktop Link Protocol(DLP) function id's, parameters, and frame
|
|
* structures.
|
|
*
|
|
* History:
|
|
* 6/7/95 vmk Created by Vitaly Marty Kruglikov
|
|
* 6/15/95 vmk Changed dlp/Read/Write/UserID to dlp/Read/Write/UserInfo and
|
|
* added the last sync PC id field to their arguments at Laura's request.
|
|
* 6/15/95 vmk Added option to dlpDeleteRecord to delete all records in DB.
|
|
*
|
|
*****************************************************************************/
|
|
|
|
#ifndef __DLCOMMON_H__
|
|
#define __DLCOMMON_H__
|
|
|
|
#include <PalmTypes.h>
|
|
|
|
/************************************************************
|
|
* DesktopLink function codes
|
|
*************************************************************/
|
|
|
|
// DlpFuncID -- function id's used in request blocks sent to
|
|
// the DesktopLink application on Pilot. The width of the function
|
|
// id base is 7 bits. The high order bit(the 8th bit) is used to
|
|
// distinguish requests from their responses -- it is cleared in request
|
|
// blocks and is set in response blocks (i.e., the response to a particular
|
|
// command will have the same function code base as the command and the
|
|
// high order bit set). See dlpFuncRespFlag defined below.
|
|
//
|
|
typedef enum DlpFuncID {
|
|
|
|
dlpReservedFunc = 0x0F, // range reserved for internal use
|
|
|
|
// DLP 1.0 FUNCTIONS START HERE (PalmOS v1.0)
|
|
dlpReadUserInfo,
|
|
|
|
dlpWriteUserInfo,
|
|
|
|
dlpReadSysInfo,
|
|
|
|
dlpGetSysDateTime,
|
|
|
|
dlpSetSysDateTime,
|
|
|
|
dlpReadStorageInfo,
|
|
|
|
dlpReadDBList,
|
|
|
|
dlpOpenDB,
|
|
|
|
dlpCreateDB,
|
|
|
|
dlpCloseDB,
|
|
|
|
dlpDeleteDB,
|
|
|
|
dlpReadAppBlock,
|
|
|
|
dlpWriteAppBlock,
|
|
|
|
dlpReadSortBlock,
|
|
|
|
dlpWriteSortBlock,
|
|
|
|
dlpReadNextModifiedRec,
|
|
|
|
dlpReadRecord,
|
|
|
|
dlpWriteRecord,
|
|
|
|
dlpDeleteRecord,
|
|
|
|
dlpReadResource,
|
|
|
|
dlpWriteResource,
|
|
|
|
dlpDeleteResource,
|
|
|
|
dlpCleanUpDatabase,
|
|
|
|
dlpResetSyncFlags,
|
|
|
|
dlpCallApplication,
|
|
|
|
dlpResetSystem,
|
|
|
|
dlpAddSyncLogEntry,
|
|
|
|
dlpReadOpenDBInfo,
|
|
|
|
dlpMoveCategory,
|
|
|
|
dlpProcessRPC, // remote procedure calls interface
|
|
|
|
dlpOpenConduit, // this command is sent before each conduit is opened
|
|
|
|
dlpEndOfSync, // ends the sync session
|
|
|
|
dlpResetRecordIndex, // resets "modified record" index
|
|
|
|
dlpReadRecordIDList, // LAST 1.0 FUNCTION
|
|
|
|
|
|
// DLP 1.1 FUNCTIONS ADDED HERE (PalmOS v2.0 Personal, and Professional)
|
|
dlpReadNextRecInCategory, // iterate through all records in category
|
|
|
|
dlpReadNextModifiedRecInCategory, // iterate through modified records in category
|
|
|
|
dlpReadAppPreference, // read application preference
|
|
|
|
dlpWriteAppPreference, // write application preference
|
|
|
|
dlpReadNetSyncInfo, // read Network HotSync settings
|
|
|
|
dlpWriteNetSyncInfo, // write Network HotSync settings
|
|
|
|
dlpReadFeature, // read a feature from Feature Manager
|
|
|
|
|
|
// DLP 1.2 FUNCTIONS ADDED HERE (PalmOS v3.0)
|
|
dlpFindDB, // find a database given creator and type, or name, or
|
|
// get info on currently-open db
|
|
dlpSetDBInfo, // change database information (name, attributes, version,
|
|
// creation, modification, backup dates, type and creator
|
|
|
|
|
|
|
|
|
|
dlpLastFunc // ***ALWAYS KEEP LAST***
|
|
|
|
} DlpFuncID;
|
|
|
|
#define dlpLastPilotV10FuncID dlpReadRecordIDList
|
|
|
|
|
|
// Desktop Link function error codes returned in the response errorCode
|
|
// field.
|
|
typedef enum DlpRespErrorCode {
|
|
dlpRespErrNone = 0, // reserve 0 for no error
|
|
dlpRespErrSystem, // general Pilot system error
|
|
dlpRespErrIllegalReq, // unknown function ID
|
|
dlpRespErrMemory, // insufficient dynamic heap memory
|
|
dlpRespErrParam, // invalid parameter
|
|
dlpRespErrNotFound, // database, record, or resource not found
|
|
dlpRespErrNoneOpen, // there are no open databases
|
|
dlpRespErrDatabaseOpen, // database is open by someone else
|
|
dlpRespErrTooManyOpenDatabases, // there are too many open databases
|
|
dlpRespErrAlreadyExists, // DB already exists
|
|
dlpRespErrCantOpen, // couldn't open DB
|
|
dlpRespErrRecordDeleted, // record is deleted
|
|
dlpRespErrRecordBusy, // record is in use by someone else
|
|
dlpRespErrNotSupported, // the requested operation is not supported
|
|
// on the given database type(record or resource)
|
|
dlpRespErrUnused1, // was dlpRespErrROMBased
|
|
dlpRespErrReadOnly, // caller does not have write access(or DB is in ROM)
|
|
dlpRespErrNotEnoughSpace, // not enough space in data store for record/resource/etc.
|
|
dlpRespErrLimitExceeded, // size limit exceeded
|
|
dlpRespErrCancelSync, // cancel the sync
|
|
|
|
dlpRespErrBadWrapper, // bad arg wrapper(for debugging)
|
|
dlpRespErrArgMissing, // required arg not found(for debugging)
|
|
dlpRespErrArgSize, // invalid argument size
|
|
|
|
dlpRespErrLastReserved = 127 // last error code reserved for Palm
|
|
// *KEEP THIS ENTRY LAST*
|
|
} DlpRespErrorCode;
|
|
|
|
|
|
// Database flags
|
|
// NOTE: THESE *MUST* MATCH THE TOUCHDOWN DB ATTRIBUTES(AT LEAST IN THE FIRST VERSION).
|
|
// ANY CHANGES MUST BE REFLECTED IN "READ DB LIST" AND
|
|
#define dlpDBFlagResDB 0x0001 // resource DB if set; record DB if cleared
|
|
|
|
#define dlpDBFlagReadOnly 0x0002 // DB is read only if set; read/write if cleared
|
|
|
|
#define dlpDBFlagAppInfoDirty 0x0004 // Set if Application Info block is dirty
|
|
// Optionally supported by an App's conduit
|
|
|
|
#define dlpDBFlagBackup 0x0008 // Set if database should be backed up to PC if
|
|
// no app-specific synchronization conduit has
|
|
// been supplied.
|
|
|
|
#define dlpDBFlagOKToInstallNewer 0x0010 // This tells the backup conduit that it's OK
|
|
// for it to install a newer version of this database
|
|
// with a different name if the current database is
|
|
// open. This mechanism is used to update the
|
|
// Graffiti Shortcuts database, for example.
|
|
|
|
#define dlpDBFlagResetAfterInstall 0x0020 // Device requires a reset after this database is
|
|
// installed.
|
|
|
|
#define dlpDBFlagCopyPrevention 0x0040 // This database should not be copied to
|
|
// another deviced.
|
|
|
|
#define dlpDBFlagOpen 0x8000 // DB is open
|
|
|
|
|
|
|
|
|
|
// Database record attributes
|
|
#define dlpRecAttrDeleted 0x80 // delete this record next sync
|
|
#define dlpRecAttrDirty 0x40 // archive this record next sync
|
|
#define dlpRecAttrBusy 0x20 // record currently in use
|
|
#define dlpRecAttrSecret 0x10 // "secret" record - password protected
|
|
#define dlpRecAttrArchived 0x08 // archived record
|
|
|
|
|
|
// Date/time will be described in the following format
|
|
// yr(2 bytes), mo(1 byte, 1-12), dy(1 byte, 1-31),
|
|
// hr(1 byte, 0-23), min(1 byte, 0-59), sec(1 byte, 0-59),
|
|
// unused(1 byte).
|
|
|
|
typedef struct DlpDateTimeType { // OFFSET
|
|
UInt16 year; // 0; year (high, low)
|
|
UInt8 month; // 2; month: 1-12
|
|
UInt8 day; // 3; day: 1-31
|
|
UInt8 hour; // 4; hour: 0-23
|
|
UInt8 minute; // 5; minute: 0-59
|
|
UInt8 second; // 6; second: 0-59
|
|
UInt8 unused; // 7; unused -- set to null!
|
|
} DlpDateTimeType; // TOTAL: 8 bytes
|
|
|
|
|
|
// Version structure
|
|
typedef struct DlpVersionType {
|
|
// OFFSET
|
|
UInt16 wMajor; // 0; major version number (0 = ignore)
|
|
UInt16 wMinor; // 2; minor version number
|
|
// TOTAL: 4 bytes
|
|
} DlpVersionType;
|
|
|
|
|
|
/************************************************************
|
|
* Request and Response headers.
|
|
*
|
|
* Each DLP request and response data block begins with the
|
|
* corresponding header structure which identifies the function
|
|
* id, argument count, and error code(responses only).
|
|
*************************************************************/
|
|
|
|
// Request header:
|
|
//
|
|
typedef struct DlpReqHeaderType {
|
|
// OFFSET
|
|
UInt8 id; // 0; request function ID
|
|
UInt8 argc; // 2; count of args that follow this header
|
|
// TOTAL: 2 bytes
|
|
} DlpReqHeaderType;
|
|
|
|
typedef DlpReqHeaderType* DlpReqHeaderPtr;
|
|
|
|
typedef struct DlpReqType {
|
|
// OFFSET
|
|
DlpReqHeaderType header; // 0; request header
|
|
// FIXED SIZE: 2 bytes
|
|
UInt8 args[2]; // 2; request arguments -- var size
|
|
} DlpReqType;
|
|
|
|
typedef DlpReqType* DlpReqPtr;
|
|
|
|
// Response header:
|
|
//
|
|
typedef struct DlpRespHeaderType {
|
|
// OFFSET
|
|
UInt8 id; // 0; response function ID
|
|
UInt8 argc; // 1; count of arguments that follow this header
|
|
UInt16 errorCode; // 2; error code
|
|
// TOTAL: 4 bytes
|
|
} DlpRespHeaderType;
|
|
|
|
typedef DlpRespHeaderType* DlpRespHeaderPtr;
|
|
|
|
typedef struct DlpRespType {
|
|
// OFFSET
|
|
DlpRespHeaderType header; // 0; response header
|
|
// FIXED SIZE: 4 bytes
|
|
UInt8 args[2]; // 4; response arguments -- var size
|
|
} DlpRespType;
|
|
|
|
typedef DlpRespType* DlpRespPtr;
|
|
|
|
|
|
// Generic request/response body type(for utility routines)
|
|
//
|
|
typedef union DlpGenericBodyType {
|
|
UInt8 id; // request/response id
|
|
DlpReqType req; // request body
|
|
DlpRespType resp; // response body
|
|
} DlpGenericBodyType;
|
|
|
|
typedef DlpGenericBodyType* DlpGenericBodyPtr;
|
|
|
|
|
|
// dlpFuncRespFlag is used to form a function response ID from a
|
|
// function ID by or'ing it with the function ID. For example: if
|
|
// dlpFuncDeleteResource is the request ID, the correct response ID
|
|
// must be (dlpFuncDeleteResource | dlpFuncRespFlag).
|
|
//
|
|
#define dlpFuncRespFlag 0x80
|
|
|
|
// dlpFuncIDMask is used to mask out the function ID value
|
|
#define dlpFuncIDMask 0x7f
|
|
|
|
// dlpFirstArgID is the value of the first argument ID to be defined for
|
|
// functions. Values below it are reserved.
|
|
//
|
|
#define dlpFirstArgID 0x20
|
|
|
|
|
|
/************************************************************
|
|
*
|
|
* Argument headers used to "wrap" request and response arguments
|
|
*
|
|
* IMPORTANT: ARGUMENT WRAPPERS IN REQUESTS AND RESPONSES MUST
|
|
* ALWAYS START ON AN EVEN-BYTE BOUNDARY. The server
|
|
* implementation expects this to be the case.
|
|
*
|
|
*************************************************************/
|
|
|
|
// dlpSmallArgFlag is used to identify "small" argument wrappers by
|
|
// or'ing it with the argument id in argument header.
|
|
//
|
|
#define dlpSmallArgFlag 0x080
|
|
|
|
// dlpShortArgIDMask is used to mask out the argument id value
|
|
//
|
|
#define dlpShortArgIDMask 0x7F
|
|
|
|
|
|
// dlpLongArgFlag is used to identify "long" argument wrappers by
|
|
// or'ing it with the argument id in argument header.
|
|
//
|
|
#define dlpLongArgFlag 0xC000
|
|
|
|
// dlpLongArgIDMask is used to mask out the argument id value
|
|
//
|
|
#define dlpLongArgIDMask 0x3FFF
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Int16 argument wrappers (v1.0-compatible)
|
|
//-------------------------------------------------------------------------
|
|
|
|
// Maximum Int16 argument size which can be "wrapped"
|
|
#define dlpMaxTinyArgSize 0x000000FFL
|
|
#define dlpMaxSmallArgSize 0x0000FFFFL
|
|
#define dlpMaxShortArgSize dlpMaxSmallArgSize
|
|
|
|
|
|
|
|
// Tiny argument header for data sizes up to 255 bytes(optimization)
|
|
//
|
|
typedef struct DlpTinyArgWrapperType {
|
|
// OFFSET
|
|
UInt8 bID; // 0; argument ID
|
|
UInt8 bSize; // 1; argument size (does NOT include this arg header)
|
|
// TOTAL: 2 bytes
|
|
} DlpTinyArgWrapperType;
|
|
|
|
typedef struct DlpTinyArgType {
|
|
DlpTinyArgWrapperType wrapper; // 0; argument header
|
|
UInt8 data[2]; // 2; argument data -- var size
|
|
} DlpTinyArgType;
|
|
|
|
|
|
// Small argument header for data sizes above 255 bytes(*may also be used for
|
|
// smaller arguments when convenient*)
|
|
//
|
|
typedef struct DlpSmallArgWrapperType {
|
|
// OFFSET
|
|
UInt8 bID; // 0; argument ID
|
|
UInt8 unused; // 1; unused(for alignment) -- set to null!
|
|
UInt16 wSize; // 2; argument size (does NOT include this arg header)
|
|
// TOTAL: 4 bytes
|
|
} DlpSmallArgWrapperType;
|
|
|
|
typedef struct DlpSmallArgType {
|
|
DlpSmallArgWrapperType wrapper; // 0; argument header
|
|
UInt8 data[2]; // 4; argument data -- var size
|
|
} DlpSmallArgType;
|
|
|
|
// Unions of Int16 argument types
|
|
typedef union DlpShortArgWrapperType {
|
|
UInt8 bID; // arg id
|
|
DlpTinyArgWrapperType tiny; // "tiny" arg wrapper
|
|
DlpSmallArgWrapperType small; // "tiny" arg wrapper
|
|
} DlpShortArgWrapperType;
|
|
typedef DlpShortArgWrapperType* DlpShortArgWrapperPtr;
|
|
|
|
typedef union DlpShortArgType {
|
|
UInt8 bID; // arg id
|
|
DlpTinyArgType tiny; // "tiny" arg
|
|
DlpSmallArgType small; // "small" arg
|
|
} DlpShortArgType;
|
|
|
|
typedef DlpShortArgType* DlpShortArgPtr;
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Int32 argument wrapper (v2.0 extension)
|
|
//-------------------------------------------------------------------------
|
|
// NOTE: Pilot v2.0 will implement the capability to parse long arguments
|
|
// but will not originate them. This will assure backwards compatibility with
|
|
// the 1.0 desktop as well as compatibility with the future version of the
|
|
// desktop software which may originate the "long" argument wrappers.
|
|
//
|
|
// Int32 argument wrappers are identified by the dlpLongArgFlag bits set
|
|
// in the argument id field.
|
|
|
|
// Maximum long argument size which can be "wrapped"
|
|
#define dlpMaxLongArgSize 0xFFFFFFFFL
|
|
|
|
typedef struct DlpLongArgWrapperType {
|
|
// OFFSET
|
|
UInt16 wID; // 0; argument ID
|
|
UInt32 dwSize; // 2; argument size (does NOT include this arg header)
|
|
// TOTAL: 6 bytes
|
|
} DlpLongArgWrapperType;
|
|
typedef DlpLongArgWrapperType* DlpLongArgWrapperPtr;
|
|
|
|
typedef struct DlpLongArgType {
|
|
// OFFSET
|
|
DlpLongArgWrapperType wrapper; // 0; argument header
|
|
UInt8 data[2]; // 6; argument data -- var size
|
|
} DlpLongArgType;
|
|
typedef DlpLongArgType* DlpLongArgPtr;
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// Unions of all argument and wrapper types
|
|
//-------------------------------------------------------------------------
|
|
|
|
// Union of all argument wrapper types
|
|
typedef union DlpGenericArgWrapperType {
|
|
DlpShortArgWrapperType shortWrap; // "Int16" arg wrapper(tiny and small)
|
|
DlpLongArgWrapperType longWrap; // "long" arg wrapper
|
|
} DlpGenericArgWrapperType;
|
|
typedef DlpGenericArgWrapperType* DlpGenericArgWrapperPtr;
|
|
|
|
|
|
// Union of all argument types
|
|
typedef union DlpGenericArgType {
|
|
DlpShortArgType shortArg; // "Int16" arg(tiny and small)
|
|
DlpLongArgType longArg; // "long" arg
|
|
} DlpGenericArgType;
|
|
typedef DlpGenericArgType* DlpGenericArgPtr;
|
|
|
|
|
|
/********************************************************************
|
|
* Desktop Link Protocol Parameters
|
|
********************************************************************/
|
|
|
|
// dlpCmdTimeoutSec -- this is the number of seconds to wait for a command
|
|
// to begin coming in before timing out
|
|
//
|
|
#define dlpCmdTimeoutSec 30
|
|
|
|
|
|
|
|
/************************************************************
|
|
* DLP function argument structures
|
|
*************************************************************/
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadUserInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments: none
|
|
//
|
|
// Response arguments:
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none.
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadUserInfoRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadUserInfoRespHdrType {
|
|
// OFFSET
|
|
UInt32 userID; // 0; user ID number (0 if none)
|
|
UInt32 viewerID; // 4; id assigned to viewer by the desktop
|
|
UInt32 lastSyncPC; // 8; last sync PC id (0 if none)
|
|
DlpDateTimeType succSyncDate; // 12; last successful sync (year = 0 if none)
|
|
DlpDateTimeType lastSyncDate; // 20; last sync date(year = 0 if none)
|
|
UInt8 userNameLen; // 28; length of user name field,
|
|
// including null (0 = no user name)
|
|
UInt8 passwordLen; // 29; length of encrypted password
|
|
// (0 = no password set)
|
|
// TOTAL: 30 bytes
|
|
} DlpReadUserInfoRespHdrType;
|
|
|
|
typedef struct DlpReadUserInfoRespType {
|
|
// OFFSET
|
|
DlpReadUserInfoRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 30 bytes
|
|
UInt8 nameAndPassword[2]; // 30; user name -- var size
|
|
// User name begins at the nameAndPassword field and is null-terminated.
|
|
// The encrypted password follows the user name and is NOT null-terminated.
|
|
// The encrypted password may contain any byte values(0-255).
|
|
} DlpReadUserInfoRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteUserInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
// user id (4 bytes)
|
|
// last sync PC id(4 bytes)
|
|
// user name
|
|
//
|
|
// Response arguments: none
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotEnoughSpace,
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteUserInfoReqArgID dlpFirstArgID
|
|
|
|
#define dlpMaxUserNameSize 41 // max user name size, including null byte
|
|
|
|
typedef struct DlpWriteUserInfoReqHdrType {
|
|
// OFFSET
|
|
UInt32 userID; // 0; user ID number
|
|
UInt32 viewerID; // 4; id assigned to viewer by the desktop
|
|
UInt32 lastSyncPC; // 8; last sync PC id
|
|
DlpDateTimeType lastSyncDate; // 12; last sync date(year = 0 if none)
|
|
UInt8 modFlags; // 20; flags indicating which values are being
|
|
// modified; see the dlpUserInfoMod...
|
|
// flags defined below
|
|
UInt8 userNameLen; // 21; user name length, including null
|
|
// TOTAL: 22 bytes
|
|
} DlpWriteUserInfoReqHdrType;
|
|
|
|
// Flags indicating which values are being changed by the dlpWriteUserInfo
|
|
// request. These flags are used in the modFlags field of DlpWriteUserInfoReqHdrType.
|
|
// These flags are additive.
|
|
//
|
|
#define dlpUserInfoModUserID 0x80 // changing the user id
|
|
#define dlpUserInfoModSyncPC 0x40 // changing the last sync PC id
|
|
#define dlpUserInfoModSyncDate 0x20 // changing sync date
|
|
#define dlpUserInfoModName 0x10 // changing user name
|
|
#define dlpUserInfoModViewerID 0x08 // changing the viewer id
|
|
|
|
typedef struct DlpWriteUserInfoReqType {
|
|
// OFFSET
|
|
DlpWriteUserInfoReqHdrType
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 22 bytes
|
|
UInt8 userName[2]; // 22; user name -- var size
|
|
// User name begins at the userName field and is null-terminated.
|
|
} DlpWriteUserInfoReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadSysInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem
|
|
//
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none. DLP v1.0 and v1.1
|
|
|
|
enum {
|
|
// NEW FOR DLP v1.2:
|
|
dlpReadSysInfoReqArgID = dlpFirstArgID
|
|
};
|
|
|
|
|
|
// dlpReadSysInfoReqArgID request arg structure
|
|
//
|
|
typedef struct DlpReadSysInfoReqType {
|
|
// OFFSET
|
|
DlpVersionType dlpVer; // 0; DLP version of the caller
|
|
// TOTAL: 4 bytes
|
|
} DlpReadSysInfoReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// Both response arguments are returned in one reply
|
|
enum {
|
|
dlpReadSysInfoRespArgID = dlpFirstArgID,
|
|
|
|
// NEW FOR DLP v1.2:
|
|
dlpReadSysInfoVerRespArgID
|
|
};
|
|
|
|
// dlpReadSysInfoRespArgID response arg structure:
|
|
//
|
|
typedef struct DlpReadSysInfoRespType {
|
|
// OFFSET
|
|
UInt32 romSWVersion; // 0; ROM-based sys software version
|
|
UInt32 localizationID;// 4; localization ID
|
|
UInt8 unused; // 8; unused(for alignment) -- set to null!
|
|
UInt8 prodIDSize; // 9; size of productID/model field
|
|
UInt32 prodID; // 10; product id (was variable size)
|
|
// TOTAL: 14 bytes
|
|
} DlpReadSysInfoRespType;
|
|
|
|
|
|
// dlpReadSysInfoVerRespArgID response arg structure:
|
|
//
|
|
typedef struct DlpReadSysInfoVerRespType {
|
|
// OFFSET
|
|
DlpVersionType dlpVer; // 0; DLP version of the device
|
|
DlpVersionType compVer; // 4; product compatibility version of the device
|
|
UInt32 dwMaxRecSize; // 8; maximum record/resource size that may be allocated on
|
|
// the device given that sufficient free memory exists
|
|
// (0xFFFFFFFF = up to available memory)
|
|
// TOTAL: 12 bytes
|
|
} DlpReadSysInfoVerRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpGetSysDateTime
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes: none
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none.
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpGetSysDateTimeRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpGetSysDateTimeRespType {
|
|
// OFFSET
|
|
DlpDateTimeType dateTime; // 0; system date/time
|
|
// TOTAL: 8 bytes
|
|
} DlpGetSysDateTimeRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpSetSysDateTime
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
// new system date/time
|
|
//
|
|
// Response arguments: none
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpSetSysDateTimeReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpSetSysDateTimeReqType {
|
|
// OFFSET
|
|
DlpDateTimeType dateTime; // 0; new system date/time
|
|
// TOTAL: 8 bytes
|
|
} DlpSetSysDateTimeReqType;
|
|
|
|
typedef DlpSetSysDateTimeReqType* DlpSetSysDateTimeReqPtr;
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadStorageInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrNotFound
|
|
|
|
// Request argument structure:
|
|
//
|
|
enum {
|
|
dlpReadStorageInfoReqArgID = dlpFirstArgID
|
|
};
|
|
|
|
typedef struct DlpReadStorInfoReqType {
|
|
// OFFSET
|
|
UInt8 startCardNo; // 0; card number to start at
|
|
// (0 = first)
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
// TOTAL: 2 bytes
|
|
} DlpReadStorInfoReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
enum {
|
|
dlpReadStorageInfoRespArgID = dlpFirstArgID,
|
|
dlpReadStorageInfoExRespArgID // v1.1 extension
|
|
};
|
|
|
|
//
|
|
// dlpReadStorageInfoRespArgID:
|
|
//
|
|
|
|
// Card info structure of variable size
|
|
typedef struct DlpCardInfoHdrType {
|
|
// OFFSET
|
|
UInt8 totalSize; // 0; total size of this card info
|
|
// *ROUNDED UP TO EVEN SIZE*
|
|
UInt8 cardNo; // 1; card number
|
|
UInt16 cardVersion; // 2; card version
|
|
DlpDateTimeType crDate; // 4; creation date/time
|
|
UInt32 romSize; // 12; ROM size
|
|
UInt32 ramSize; // 16; RAM size
|
|
UInt32 freeRam; // 20; total free data store RAM - Fixed in DLP v1.2 to exclude
|
|
// dynamic heap RAM
|
|
UInt8 cardNameSize; // 24; size of card name string
|
|
UInt8 manufNameSize; // 25; size of manuf. name string
|
|
// TOTAL: 26 bytes;
|
|
} DlpCardInfoHdrType;
|
|
|
|
typedef struct DlpCardInfoType {
|
|
// OFFSET
|
|
DlpCardInfoHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 26 bytes;
|
|
UInt8 cardNameAndManuf[2];
|
|
// 26; card name and manuf. text -- var size
|
|
// Card name is the cardNameSize bytes of text at cardNameAndManuf,
|
|
// followed immediately by manufNameSize bytes of manufacturer name.
|
|
} DlpCardInfoType;
|
|
|
|
|
|
typedef struct DlpReadStorInfoRespHdrType {
|
|
// OFFSET
|
|
UInt8 lastCardNo; // 0; card number of last card retrieved
|
|
UInt8 more; // 1; non-zero if there are more cards
|
|
UInt8 unused; // 2; unused -- set to null!
|
|
UInt8 actCount; // 3; actual count of structures returned
|
|
// TOTAL: 4 bytes
|
|
} DlpReadStorInfoRespHdrType;
|
|
|
|
typedef struct DlpReadStorInfoRespType {
|
|
// OFFSET
|
|
DlpReadStorInfoRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 4 bytes
|
|
DlpCardInfoType cardInfo[1]; // 4; actCount of card info structures -- var size
|
|
} DlpReadStorInfoRespType;
|
|
|
|
|
|
//
|
|
// EXTENDED ARGUMENTS(DL v1.1): dlpReadStorageInfoExRespArgID
|
|
//
|
|
typedef struct DlpReadStorInfoExRespType {
|
|
// OFFSET
|
|
UInt16 romDBCount; // 0; ROM database count
|
|
UInt16 ramDBCount; // 2; RAM database count
|
|
UInt32 dwReserved1; // 4; RESERVED -- SET TO NULL!
|
|
UInt32 dwReserved2; // 8; RESERVED -- SET TO NULL!
|
|
UInt32 dwReserved3; // 12; RESERVED -- SET TO NULL!
|
|
UInt32 dwReserved4; // 16; RESERVED -- SET TO NULL!
|
|
// TOTAL: 20 bytes
|
|
} DlpReadStorInfoExRespType;
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadDBList
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrNotFound
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpReadDBListReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadDBListReqType {
|
|
// OFFSET
|
|
UInt8 srchFlags; // 0; search flags
|
|
UInt8 cardNo; // 1; card number -- 0-based
|
|
UInt16 startIndex; // 2; DB index to start at
|
|
// (0 = from beginning)
|
|
// TOTAL: 4 bytes
|
|
} DlpReadDBListReqType;
|
|
|
|
#define dlpReadDBListFlagRAM 0x80 // Search for RAM-based
|
|
#define dlpReadDBListFlagROM 0x40 // Search for ROM-based
|
|
#define dlpReadDBListFlagMultiple 0x20 // OK to return multiple entries (DEFINED FOR DLP v1.2)
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadDBListRespArgID dlpFirstArgID
|
|
|
|
// Database info structure of variable size
|
|
typedef struct DlpDBInfoHdrType {
|
|
// OFFSET
|
|
UInt8 totalSize; // 0; total size of the DB info (DlpDBInfoHdrType + name)
|
|
// *ROUNDED UP TO EVEN SIZE*
|
|
UInt8 miscFlags; // 1; dlpDbInfoMiscFlag... flags(v1.1) -- set all unused bits to null!
|
|
UInt16 dbFlags; // 2; DB flags: dlpDBFlagReadOnly,
|
|
// dlpDBFlagResDB, dlpDBFlagAppInfoDirty, dlpDBFlagOpen,
|
|
// dlpDBFlagBackup, etc;
|
|
UInt32 type; // 4; database type
|
|
UInt32 creator; // 8; database creator
|
|
UInt16 version; // 12; database version
|
|
UInt32 modNum; // 14; modification number
|
|
DlpDateTimeType crDate; // 18; creation date
|
|
DlpDateTimeType modDate; // 26; latest modification date
|
|
DlpDateTimeType backupDate; // 34; latest backup date
|
|
UInt16 dbIndex; // 42; DB index (or dlpDbInfoUnknownDbIndex for dlpFindDB)
|
|
// TOTAL: 44 bytes;
|
|
} DlpDBInfoHdrType;
|
|
|
|
// Flags for the miscFlags field of DlpDBInfoHdrType
|
|
#define dlpDbInfoMiscFlagExcludeFromSync 0x80 // DEFINED FOR DLP v1.1
|
|
#define dlpDbInfoMiscFlagRamBased 0x40 // DEFINED FOR DLP v1.2
|
|
|
|
// Unknown index value for the dbIndex field of DlpDBInfoHdrType
|
|
#define dlpDbInfoUnknownDbIndex 0xFFFF
|
|
|
|
|
|
typedef struct DlpDBInfoType {
|
|
// OFFSET
|
|
DlpDBInfoHdrType header; // 0; fixed-size header
|
|
// FIXED SIZE: 44 bytes;
|
|
UInt8 name[2]; // 44; databse name text -- var size and
|
|
// null-terminated
|
|
} DlpDBInfoType;
|
|
|
|
|
|
typedef struct DlpReadDBListRespHdrType {
|
|
// OFFSET
|
|
UInt16 lastIndex; // 0; DB index of last entry retrieved
|
|
UInt8 flags; // 2; flags: dlpReadDBListRespFlagMore
|
|
UInt8 actCount; // 3; actual count of structures returned
|
|
// TOTAL: 4 bytes
|
|
} DlpReadDBListRespHdrType;
|
|
|
|
// dlpReadDBListRespFlagMore flag: if set, indicates that there are more
|
|
// databases to list -- this enables the server to send the listing
|
|
// incrementally, reducing server memory requirements if necessary
|
|
#define dlpReadDBListRespFlagMore 0x80
|
|
|
|
typedef struct DlpReadDBListRespType {
|
|
// OFFSET
|
|
DlpReadDBListRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 4 bytes
|
|
DlpDBInfoType dbInfo[1]; // 4; actCount of DB info structures -- var size
|
|
} DlpReadDBListRespType;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpOpenDB
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrTooManyOpenDatabases
|
|
// dlpRespErrCantOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpOpenDBReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpOpenDBReqHdrType {
|
|
// OFFSET
|
|
UInt8 cardNo; // 0; memory module number
|
|
UInt8 mode; // 1; open mode
|
|
// TOTAL: 2 bytes;
|
|
} DlpOpenDBReqHdrType;
|
|
|
|
#define dlpOpenDBModeRead 0x80
|
|
#define dlpOpenDBModeWrite 0x40
|
|
#define dlpOpenDBModeExclusive 0x20
|
|
#define dlpOpenDBModeShowSecret 0x10
|
|
|
|
|
|
typedef struct DlpOpenDBReqType {
|
|
// OFFSET
|
|
DlpOpenDBReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 2 bytes;
|
|
UInt8 name[2]; // 2; databse name text -- var size
|
|
// zero-terminated
|
|
} DlpOpenDBReqType;
|
|
|
|
typedef DlpOpenDBReqType* DlpOpenDBReqPtr;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpOpenDBRespArgID dlpFirstArgID
|
|
//
|
|
// The response argument is the 1-byte database ID to be passed in
|
|
// subsequent read/write requests.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpCreateDB
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrAlreadyExists,
|
|
// dlpRespErrCantOpen,
|
|
// dlpRespErrNotEnoughSpace,
|
|
// dlpRespErrTooManyOpenDatabases
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpCreateDBReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpCreateDBReqHdrType {
|
|
// OFFSET
|
|
UInt32 creator; // 0; DB creator
|
|
UInt32 type; // 4; DB type
|
|
UInt8 cardNo; // 8; memory module number
|
|
UInt8 unused; // 9; unused -- set to null
|
|
UInt16 dbFlags; // 10; allowed flags: dlpDBFlagResDB,
|
|
// dlpDBFlagBackup, dlpDBFlagOKToInstallNewer,
|
|
// dlpDBFlagResetAfterInstall
|
|
UInt16 version; // 12; DB version #
|
|
// TOTAL: 14 bytes;
|
|
} DlpCreateDBReqHdrType;
|
|
|
|
typedef struct DlpCreateDBReqType {
|
|
// OFFSET
|
|
DlpCreateDBReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 12 bytes;
|
|
UInt8 name[2]; // 14; DB name text -- var size
|
|
// zero-terminated
|
|
} DlpCreateDBReqType;
|
|
|
|
typedef DlpCreateDBReqType* DlpCreateDBReqPtr;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpCreateDBRespArgID dlpFirstArgID
|
|
|
|
// The response argument is the 1-byte database ID to be passed in
|
|
// subsequent read/write requests.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpCloseDB
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrParam,
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
typedef enum {
|
|
dlpCloseDBReqArgID = dlpFirstArgID, // close a specific database
|
|
dlpCloseDBAllReqArgID, // close all databases
|
|
dlpCloseDBExReqArgID // close a specific db and update backup
|
|
// and/or modification dates (PalmOS v3.0)
|
|
} DlpCloseDBReqArgID;
|
|
|
|
// Argument structure to close a specific database(dlpCloseDBDBIDReqArgID):
|
|
//
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
typedef UInt8 DlpCloseDBReqType;
|
|
|
|
// Argument structure to close all databases(dlpCloseDBReqAllArgID):
|
|
//
|
|
// This request argument contains no data
|
|
|
|
|
|
// Request type for dlpCloseDBExReqArgID (PalmOS v3.0):
|
|
typedef struct DlpCloseDBExReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id to close
|
|
UInt8 bOptFlags; // 1; bitfield of dlpCloseDBExOptFlag... flags
|
|
// TOTAL: 2 bytes
|
|
} DlpCloseDBExReqType;
|
|
|
|
// Option flags
|
|
#define dlpCloseDBExOptFlagUpdateBackupDate 0x80 // Update the backup date after closing
|
|
#define dlpCloseDBExOptFlagUpdateModDate 0x40 // Update the modification date after closing
|
|
|
|
|
|
#define dlpCloseDBExOptAllFlags (dlpCloseDBExOptFlagUpdateBackupDate | dlpCloseDBExOptFlagUpdateModDate)
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpDeleteDB
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound,
|
|
// dlpRespErrCantOpen,
|
|
// dlpRespErrDatabaseOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpDeleteDBReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpDeleteDBReqHdrType {
|
|
// OFFSET
|
|
UInt8 cardNo; // 0; memory module number
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
// TOTAL: 2 bytes;
|
|
} DlpDeleteDBReqHdrType;
|
|
|
|
|
|
typedef struct DlpDeleteDBReqType {
|
|
// OFFSET
|
|
DlpDeleteDBReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 2 bytes;
|
|
UInt8 name[2]; // 2; databse name text -- var size
|
|
// zero-terminated
|
|
} DlpDeleteDBReqType;
|
|
|
|
typedef DlpDeleteDBReqType* DlpDeleteDBReqPtr;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadOpenDBInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Get information on an open database
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrNoneOpen
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpReadOpenDBInfoArgID dlpFirstArgID
|
|
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadOpenDBInfoRespArgID dlpFirstArgID
|
|
|
|
|
|
typedef struct DlpReadOpenDBInfoRespType {
|
|
// OFFSET
|
|
UInt16 numRec; // 0; number of records or resources
|
|
// TOTAL: 2 bytes
|
|
} DlpReadOpenDBInfoRespType;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpMoveCategory
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrNoneOpen
|
|
// dlpRespErrParam
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrReadOnly
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpMoveCategoryReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpMoveCategoryReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 fromCategory; // 1; id of the "from" category
|
|
UInt8 toCategory; // 2; id of the "to" category
|
|
UInt8 unused; // 3; unused -- set to null!
|
|
// TOTAL: 4 bytes;
|
|
} DlpMoveCategoryReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadAppBlock
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNoneOpen
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpReadBlockReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadBlockReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt16 offset; // 2; offset into the block
|
|
UInt16 numBytes; // 4; number of bytes to read starting
|
|
// at offset(-1 = to the end)
|
|
// TOTAL: 6 bytes;
|
|
} DlpReadBlockReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadBlockRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadBlockRespHdrType {
|
|
// OFFSET
|
|
UInt16 blockSize; // 0; actual block size -- may be greater
|
|
// than the amount of data returned
|
|
// TOTAL: 2 bytes
|
|
} DlpReadBlockRespHdrType;
|
|
|
|
typedef struct DlpReadBlockRespType {
|
|
// OFFSET
|
|
DlpReadBlockRespHdrType //
|
|
header; // 0; fixed size header
|
|
// FIXED SIZE: 2 bytes
|
|
UInt8 data[2]; // 2; block data -- var size
|
|
} DlpReadBlockRespType;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteAppBlock
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrReadOnly
|
|
// dlpRespErrNotEnoughSpace
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteBlockReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpWriteBlockReqHdrType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt16 blockSize; // 2; total block size(0 = free existing block)
|
|
// TOTAL: 4 bytes;
|
|
} DlpWriteBlockReqHdrType;
|
|
|
|
|
|
typedef struct DlpWriteBlockReqType {
|
|
// OFFSET
|
|
DlpWriteBlockReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 4 bytes;
|
|
UInt8 data[2]; // 4; block data -- var size
|
|
} DlpWriteBlockReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadSortBlock
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
// see dlpReadAppBlock
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// see dlpReadAppBlock
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteSortBlock
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
// see dlpWriteAppBlock
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadNextModifiedRec
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// see dlpReadRecord
|
|
//
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpReadNextModRecReqArgID dlpFirstArgID
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// Response argument id = dlpReadRecordRespArgID
|
|
|
|
// Response argument structure = DlpReadRecordRespType
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpResetRecordIndex
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Resets the "next modified record" index to the beginning
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrParam
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpResetRecordIndexReqArgID dlpFirstArgID
|
|
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadRecord
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrNotSupported,
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound,
|
|
// dlpRespErrRecordBusy,
|
|
// dlpRespErrNoneOpen
|
|
|
|
typedef enum {
|
|
dlpReadRecordIdArgID = dlpFirstArgID,
|
|
dlpReadRecordIndexArgID
|
|
} DlpReadRecordReqArgID;
|
|
|
|
// dlpReadRecordIdArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadRecordByIDReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt32 recordID; // 2; unique record id
|
|
UInt16 offset; // 6; offset into the record
|
|
UInt16 numBytes; // 8; number of bytes to read starting
|
|
// at the offset(-1 = "to the end")
|
|
// TOTAL: 10 bytes;
|
|
} DlpReadRecordByIDReqType;
|
|
|
|
// dlpReadRecordIndexArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadRecordByIndexReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt16 index; // 2; record index
|
|
UInt16 offset; // 4; offset into the record
|
|
UInt16 numBytes; // 6; number of bytes to read starting
|
|
// at the offset(-1 = "to the end")
|
|
// TOTAL: 8 bytes;
|
|
} DlpReadRecordByIndexReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadRecordRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadRecordRespHdrType {
|
|
// OFFSET
|
|
UInt32 recordID; // 0; unique record id
|
|
UInt16 index; // 4; record index
|
|
UInt16 recSize; // 6; total record size in bytes
|
|
UInt8 attributes; // 8; record attributes
|
|
UInt8 category; // 9; record category index
|
|
// TOTAL: 10 bytes;
|
|
} DlpReadRecordRespHdrType;
|
|
|
|
typedef struct DlpReadRecordRespType {
|
|
// OFFSET
|
|
DlpReadRecordRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 8 bytes;
|
|
UInt8 data[2]; // 8; record data -- var size
|
|
} DlpReadRecordRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadRecordIDList
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Returns a list of unique record id's. May need to call more than once
|
|
// to get the entire list. dlpRespErrNotFound is returned when "start"
|
|
// is out of bounds
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrNotSupported,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound,
|
|
// dlpRespErrNoneOpen
|
|
|
|
#define dlpReadRecordIDListReqArgID dlpFirstArgID
|
|
|
|
// dlpReadRecordIDListReqArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadRecordIDListReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 flags; // 1; request flags
|
|
UInt16 start; // 2; starting record index (0-based)
|
|
UInt16 maxEntries; // 4; maximum number of entries, or
|
|
// 0xFFFF to return as many as possible
|
|
// TOTAL: 6 bytes;
|
|
} DlpReadRecordIDListReqType;
|
|
|
|
// dlpReadRecordIDListFlagSortDB: if set, DL Server will call the creator
|
|
// application to resort the database before returning the list.
|
|
#define dlpReadRecordIDListFlagSortDB 0x80
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadRecordIDListRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadRecordIDListRespHdrType {
|
|
// OFFSET
|
|
UInt16 numEntries; // 0; number of entries returned
|
|
// TOTAL: 2 bytes;
|
|
} DlpReadRecordIDListRespHdrType;
|
|
|
|
typedef struct DlpReadRecordIDListRespType {
|
|
// OFFSET
|
|
DlpReadRecordIDListRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 2 bytes;
|
|
UInt32 recID[1]; // 8; list of record id's -- var size
|
|
} DlpReadRecordIDListRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteRecord
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNotEnoughSpace
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrReadOnly
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteRecordReqArgID dlpFirstArgID
|
|
|
|
// dlpWriteRecordReqArgID -- required
|
|
typedef struct DlpWriteRecordReqHdrType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 flags; // 1; set unused bits to null!
|
|
UInt32 recordID; // 2; unique record id or null
|
|
UInt8 attributes; // 6; record attributes -- only
|
|
// dlpRecAttrSecret is allowed here
|
|
// v1.1 extension:
|
|
// dlpRecAttrDeleted, dlpRecAttrArchived and
|
|
// dlpRecAttrDirty are also allowed.
|
|
UInt8 category; // 7; record category
|
|
// TOTAL: 8 bytes;
|
|
} DlpWriteRecordReqHdrType;
|
|
|
|
#define dlpWriteRecordReqFlagDataIncluded 0x80 // original implementer of destop software always
|
|
// set this bit. Define it here for compatibility
|
|
|
|
typedef struct DlpWriteRecordReqType {
|
|
// OFFSET
|
|
DlpWriteRecordReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 8 bytes;
|
|
UInt8 data[2]; // 8; record data -- var size
|
|
} DlpWriteRecordReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpWriteRecordRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpWriteRecordRespType {
|
|
// OFFSET
|
|
UInt32 recordID; // 0; record ID
|
|
// TOTAL: 4 bytes
|
|
} DlpWriteRecordRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpDeleteRecord
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrReadOnly
|
|
// dlpRespErrNoneOpen
|
|
//
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpDeleteRecordReqArgID dlpFirstArgID
|
|
|
|
// Argument structure to delete by record ID(dlpDeleteRecordReqIDArgID):
|
|
typedef struct DlpDeleteRecordReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 flags; // 1; flags (dlpDeleteRecFlagDeleteAll)
|
|
UInt32 recordID; // 2; unique record id (see flags)
|
|
// TOTAL: 6 bytes;
|
|
} DlpDeleteRecordReqType;
|
|
|
|
// dlpDeleteRecFlagDeleteAll: if this flag is set, the reocordID field
|
|
// is ignored and all database records will be deleted
|
|
#define dlpDeleteRecFlagDeleteAll 0x80
|
|
|
|
// dlpDeleteRecFlagByCategory: if this flag is set, the least significant byte
|
|
// of the reocordID field contains the category id of records to be deleted (PalmOS 2.0)
|
|
#define dlpDeleteRecFlagByCategory 0x40
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadResource
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNoneOpen
|
|
|
|
typedef enum {
|
|
dlpReadResourceIndexArgID = dlpFirstArgID,
|
|
dlpReadResourceTypeArgID
|
|
} DlpReadResourceReqArgID;
|
|
|
|
// dlpReadResourceIndexArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadResourceByIndexReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt16 index; // 2; resource index
|
|
UInt16 offset; // 4; offset into the resource
|
|
UInt16 numBytes; // 6; number of bytes to read starting
|
|
// at the offset(-1 = "to the end")
|
|
// TOTAL: 8 bytes;
|
|
} DlpReadResourceByIndexReqType;
|
|
|
|
// dlpReadResourceTypeArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadResourceByTypeReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; unused -- set to null!
|
|
UInt32 type; // 2; resource type
|
|
UInt16 id; // 6; resource id
|
|
UInt16 offset; // 8; offset into the resource
|
|
UInt16 numBytes; // 10; number of bytes to read starting
|
|
// at the offset(-1 = "to the end")
|
|
// TOTAL: 12 bytes;
|
|
} DlpReadResourceByTypeReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadResourceRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadResourceRespHdrType {
|
|
// OFFSET
|
|
UInt32 type; // 0; resource type
|
|
UInt16 id; // 4; resource id
|
|
UInt16 index; // 6; resource index
|
|
UInt16 resSize; // 8; total resource size in bytes
|
|
// TOTAL: 10 bytes;
|
|
} DlpReadResourceRespHdrType;
|
|
|
|
typedef struct DlpReadResourceRespType {
|
|
// OFFSET
|
|
DlpReadResourceRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 6 bytes;
|
|
UInt8 resData[2]; // 6; resource data -- var size
|
|
} DlpReadResourceRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteResource
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotEnoughSpace,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteResourceReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpWriteResourceReqHdrType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 unused; // 1; inused -- set to null!
|
|
UInt32 type; // 2; resource type
|
|
UInt16 id; // 6; resource id
|
|
UInt16 resSize; // 8; total resource size
|
|
// TOTAL: 10 bytes;
|
|
} DlpWriteResourceReqHdrType;
|
|
|
|
typedef struct DlpWriteResourceReqType {
|
|
// OFFSET
|
|
DlpWriteResourceReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 10 bytes;
|
|
UInt8 data[2]; // 10; resource data -- var size
|
|
} DlpWriteResourceReqType;
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpDeleteResource
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrReadOnly
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpDeleteResourceReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpDeleteResourceReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 flags; // 1; flags (dlpDeleteResFlagDeleteAll)
|
|
UInt32 type; // 2; resource type
|
|
UInt16 id; // 6; resource id
|
|
// TOTAL: 8 bytes;
|
|
} DlpDeleteResourceReqType;
|
|
|
|
// dlpDeleteResFlagDeleteAll: if set, all resources in the db will be deleted
|
|
#define dlpDeleteResFlagDeleteAll 0x80
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpCleanUpDatabase
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Deletes all records which are marked as archived or deleted in the
|
|
// record database
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrReadOnly,
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpCleanUpDatabaseReqArgID dlpFirstArgID
|
|
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpResetSyncFlags
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// For record databases, reset all dirty flags.
|
|
// For both record and resource databases, set the last sync time to NOW
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam
|
|
// dlpRespErrReadOnly,
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpResetSyncFlagsReqArgID dlpFirstArgID
|
|
|
|
// The request argument is the 1-byte database ID returned in open/create
|
|
// DB responses.
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpCallApplication
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Call an application entry point via an action code
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
|
|
// Request argument structure:
|
|
//
|
|
enum {
|
|
dlpCallApplicationReqArgIDV10 = dlpFirstArgID, // req id for Pilot v1.0
|
|
dlpCallAppReqArgID // req id for Pilot v2.0 and later
|
|
};
|
|
|
|
// dlpCallApplicationReqArgIDV10:
|
|
typedef struct DlpCallApplicationReqHdrTypeV10 {
|
|
// OFFSET
|
|
UInt32 creator; // 0; app DB creator id
|
|
UInt16 action; // 4; action code
|
|
UInt16 paramSize; // 6; custom param size
|
|
// TOTAL: 8 bytes
|
|
} DlpCallApplicationReqHdrTypeV10;
|
|
|
|
typedef struct DlpCallApplicationReqTypeV10 {
|
|
// OFFSET
|
|
DlpCallApplicationReqHdrTypeV10 //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 8 bytes
|
|
UInt8 paramData[2]; // 8; custom param data -- var size
|
|
} DlpCallApplicationReqTypeV10;
|
|
|
|
|
|
// dlpCallAppReqArgID (Pilot v2.0):
|
|
typedef struct DlpCallAppReqHdrType {
|
|
// OFFSET
|
|
UInt32 creator; // 0; DB creator id of target executable
|
|
UInt32 type; // 4; DB type id of target executable
|
|
UInt16 action; // 8; action code
|
|
UInt32 dwParamSize; // 10; custom param size in number of bytes
|
|
UInt32 dwReserved1; // 14; RESERVED -- set to NULL!!!
|
|
UInt32 dwReserved2; // 18; RESERVED -- set to NULL!!!
|
|
// TOTAL: 22 bytes
|
|
} DlpCallAppReqHdrType;
|
|
|
|
typedef struct DlpCallAppReqType {
|
|
// OFFSET
|
|
DlpCallAppReqHdrType //
|
|
hdr; // 0; fixed-size header
|
|
// FIXED SIZE: 22 bytes
|
|
UInt8 paramData[2]; // 22; custom param data -- var size
|
|
} DlpCallAppReqType;
|
|
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
enum {
|
|
dlpCallApplicationRespArgIDV10 = dlpFirstArgID, // resp id for Pilot v1.0
|
|
dlpCallAppRespArgID // resp id for Pilot v2.0 and later
|
|
};
|
|
|
|
// dlpCallApplicationRespArgIDV10:
|
|
typedef struct DlpCallApplicationRespHdrTypeV10 {
|
|
// OFFSET
|
|
UInt16 action; // 0; action code which was called
|
|
UInt16 resultCode; // 2; result error code returned by action
|
|
UInt16 resultSize; // 4; custom result data size
|
|
// TOTAL: 6 bytes
|
|
} DlpCallApplicationRespHdrTypeV10;
|
|
|
|
typedef struct DlpCallApplicationRespTypeV10 {
|
|
// OFFSET
|
|
DlpCallApplicationRespHdrTypeV10 //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 6 bytes
|
|
UInt8 resultData[2]; // 6; custom result data -- var size
|
|
} DlpCallApplicationRespTypeV10;
|
|
|
|
// dlpCallAppRespArgID:
|
|
typedef struct DlpCallAppRespHdrType {
|
|
// OFFSET
|
|
UInt32 dwResultCode; // 0; result error code returned by handler
|
|
UInt32 dwResultSize; // 4; custom result data size
|
|
UInt32 dwReserved1; // 8; RESERVED -- SET TO NULL!!!
|
|
UInt32 dwReserved2; // 12; RESERVED -- SET TO NULL!!!
|
|
// TOTAL: 16 bytes
|
|
} DlpCallAppRespHdrType;
|
|
|
|
typedef struct DlpCallAppRespType {
|
|
// OFFSET
|
|
DlpCallAppRespHdrType //
|
|
hdr; // 0; fixed-size header
|
|
// FIXED SIZE: 16 bytes
|
|
UInt8 resultData[2]; // 16; custom result data -- var size
|
|
} DlpCallAppRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpResetSystem
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none.
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpAddSyncLogEntry
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotEnoughSpace,
|
|
// dlpRespErrLimitExceeded,
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpAddSyncLogEntryReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpAddSyncLogEntryReqType {
|
|
// OFFSET
|
|
UInt8 text[2]; // 0; entry text -- var size and
|
|
// null-terminated
|
|
} DlpAddSyncLogEntryReqType;
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpProcessRPC
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Remote Procedure Call interface
|
|
//
|
|
// Request arguments:
|
|
// RPC command block
|
|
//
|
|
// Response arguments:
|
|
// RPC reply block
|
|
//
|
|
// Possible error codes
|
|
// 0 on success; otherwise error code from the TouchDown
|
|
// RPC executor
|
|
//
|
|
// NOTE: this is a low-level system command which does not use arg wrappers.
|
|
|
|
// Request argument structure:
|
|
//
|
|
// Block of RPC command data (no arg wrapper)
|
|
|
|
// Response argument structure:
|
|
//
|
|
// Block of RPC reply data of same length as command block(no arg wrapper)
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpOpenConduit
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// This command is sent before each conduit is opened by the desktop.
|
|
// If the viewer has a cancel pending, it will return dlpRespErrCancelSync
|
|
// in the response header's errorCode field.
|
|
//
|
|
// Request arguments: none.
|
|
//
|
|
// Response arguments: none.
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrCancelSync
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none.
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpEndOfSync
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// This command is sent by the desktop to end the sync.
|
|
//
|
|
// Request arguments: termination code: 0 = normal termination;
|
|
// otherwise the client is aborting the sync
|
|
//
|
|
// Possible error codes
|
|
// 0
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpEndOfSyncReqArgID dlpFirstArgID
|
|
|
|
typedef enum DlpSyncTermCode {
|
|
dlpTermCodeNormal = 0, // normal termination
|
|
dlpTermCodeOutOfMemory, // termination due to low memory on TD
|
|
dlpTermCodeUserCan, // user cancelled from desktop
|
|
dlpTermCodeOther, // catch-all abnormal termination code
|
|
dlpTermCodeIncompatibleProducts // incompatibility between desktop and handheld hotsync products
|
|
} DlpSyncTermCode;
|
|
|
|
|
|
typedef struct DlpEndOfSyncReqType {
|
|
// OFFSET
|
|
UInt16 termCode; // 0; termination code
|
|
// TOTAL: 2 bytes
|
|
} DlpEndOfSyncReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadNextRecInCategory
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// see dlpReadRecord
|
|
|
|
#define dlpReadNextRecInCategoryReqArgID dlpFirstArgID
|
|
|
|
// dlpReadNextRecInCategoryReqArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadNextRecInCategoryReqType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id
|
|
UInt8 category; // 1; category id
|
|
// TOTAL: 2 bytes;
|
|
} DlpReadNextRecInCategoryReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// Response argument id = dlpReadRecordRespArgID
|
|
|
|
// Response argument structure = DlpReadRecordRespType
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadNextModifiedRecInCategory
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// see dlpReadNextRecInCategory
|
|
|
|
// Request argument structure:
|
|
//
|
|
// same as dlpReadNextRecInCategory
|
|
|
|
// Response argument structure:
|
|
//
|
|
// same as dlpReadNextRecInCategory
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadAppPreference
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound,
|
|
|
|
#define dlpReadAppPreferenceReqArgID dlpFirstArgID
|
|
|
|
// dlpReadAppPreferenceReqArgID request argument structure:
|
|
//
|
|
typedef struct DlpReadAppPreferenceReqType {
|
|
// OFFSET
|
|
UInt32 creator; // 0; application creator type
|
|
UInt16 id; // 4; preference id
|
|
UInt16 reqBytes; // 6; max. number of preference bytes requested;
|
|
// pass 0xFFFF for actual size
|
|
UInt8 flags; // 8; command flags: dlpAppPrefReqFlagBackedUp - if set, use backed-up pref db
|
|
UInt8 unused; // 9; reserved/padding -- set to NUL!
|
|
// TOTAL: 10 bytes;
|
|
} DlpReadAppPreferenceReqType;
|
|
|
|
#define dlpReadAppPrefActualSize 0xFFFF
|
|
#define dlpAppPrefReqFlagBackedUp 0x80
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadAppPreferenceRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadAppPreferenceRespHdrType {
|
|
// OFFSET
|
|
UInt16 version; // 0; version number of the application
|
|
UInt16 actualSize; // 2; actual preference data size
|
|
UInt16 retBytes; // 4; number of preference bytes returned
|
|
// TOTAL: 6 bytes
|
|
} DlpReadAppPreferenceRespHdrType;
|
|
|
|
typedef struct DlpReadAppPreferenceRespType {
|
|
// OFFSET
|
|
DlpReadAppPreferenceRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 6 bytes
|
|
UInt8 data[2]; // 6; custom result data -- var size
|
|
} DlpReadAppPreferenceRespType;
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteAppPreference
|
|
//////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotEnoughSpace
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteAppPreferenceReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpWriteAppPreferenceReqHdrType {
|
|
// OFFSET
|
|
UInt32 creator; // 0; application creator type
|
|
UInt16 id; // 4; preference id
|
|
UInt16 version; // 6; version number of the application
|
|
UInt16 prefSize; // 8; preference size(in number of bytes)
|
|
UInt8 flags; // 10; command flags: dlpAppPrefReqFlagBackedUp - if set, use backed-up pref db
|
|
UInt8 unused; // 11; reserved/padding -- set to NUL!
|
|
// TOTAL: 12 bytes;
|
|
} DlpWriteAppPreferenceReqHdrType;
|
|
|
|
typedef struct DlpWriteAppPreferenceReqType {
|
|
// OFFSET
|
|
DlpWriteAppPreferenceReqHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 12 bytes;
|
|
UInt8 data[2]; // 12; record data -- var size
|
|
} DlpWriteAppPreferenceReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadNetSyncInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments: none
|
|
//
|
|
// Response arguments:
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrMemory
|
|
|
|
// Request argument structure:
|
|
//
|
|
// none.
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadNetSyncInfoRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadNetSyncInfoRespHdrType {
|
|
// OFFSET
|
|
UInt8 lanSyncOn; // 0; non-zero if Lan Sync is enabled
|
|
UInt8 bReserved1; // 1; reserved -- SET TO NULL!
|
|
UInt32 dwReserved1; // 2; reserved -- SET TO NULL!
|
|
UInt32 dwReserved2; // 6; reserved -- SET TO NULL!
|
|
UInt32 dwReserved3; // 10; reserved -- SET TO NULL!
|
|
UInt32 dwReserved4; // 14; reserved -- SET TO NULL!
|
|
UInt16 syncPCNameSize;// 18; length of sync PC host name,
|
|
// including null (0 = no host name)
|
|
UInt16 syncPCAddrSize;// 20; length of sync PC address,
|
|
// including null (0 = no address)
|
|
UInt16 syncPCMaskSize;// 22; length of sync PC subnet mask,
|
|
// including null (0 = no mask)
|
|
// TOTAL: 24 bytes
|
|
} DlpReadNetSyncInfoRespHdrType;
|
|
|
|
typedef struct DlpReadNetSyncInfoRespType {
|
|
// OFFSET
|
|
DlpReadNetSyncInfoRespHdrType //
|
|
hdr; // 0; fixed-size header
|
|
// FIXED SIZE: 24 bytes
|
|
UInt8 syncAddr[2]; // 24; sync IP address/host name -- var size,
|
|
// null-terminated
|
|
} DlpReadNetSyncInfoRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpWriteNetSyncInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
//
|
|
// Response arguments: none
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotEnoughSpace,
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpWriteNetSyncInfoReqArgID dlpFirstArgID
|
|
|
|
#define dlpMaxHostAddrLength 255 // maximum PC host name length, not including NULL
|
|
|
|
typedef struct DlpWriteNetSyncInfoReqHdrType {
|
|
// OFFSET
|
|
UInt8 modFlags; // 0; flags indicating which values are being
|
|
// modified; see the dlpNetSyncInfoMod...
|
|
// flags defined below
|
|
UInt8 lanSyncOn; // 1; non-zero if Lan Sync is enabled
|
|
UInt32 dwReserved1; // 2; reserved -- SET TO NULL!
|
|
UInt32 dwReserved2; // 6; reserved -- SET TO NULL!
|
|
UInt32 dwReserved3; // 10; reserved -- SET TO NULL!
|
|
UInt32 dwReserved4; // 14; reserved -- SET TO NULL!
|
|
UInt16 syncPCNameSize;// 18; length of sync PC host name,
|
|
// including null (0 = no address/host name)
|
|
UInt16 syncPCAddrSize;// 20; length of sync PC address,
|
|
// including null (0 = no address)
|
|
UInt16 syncPCMaskSize;// 22; length of sync PC subnet mask,
|
|
// including null (0 = no mask)
|
|
// TOTAL: 24 bytes
|
|
} DlpWriteNetSyncInfoReqHdrType;
|
|
|
|
// Flags indicating which values are being changed by the dlpWriteNetSyncInfo
|
|
// request. These flags are used in the modFlags field of DlpWriteNetSyncInfoReqHdrType.
|
|
// These flags are additive.
|
|
//
|
|
#define dlpNetSyncInfoModLanSyncOn 0x80 // changing the "lan sync on" setting
|
|
#define dlpNetSyncInfoModSyncPCName 0x40 // changing the sync PC host name
|
|
#define dlpNetSyncInfoModSyncPCAddr 0x20 // changing the sync PC address
|
|
#define dlpNetSyncInfoModSyncPCMask 0x10 // changing the sync PC subnet mask
|
|
|
|
typedef struct DlpWriteNetSyncInfoReqType {
|
|
// OFFSET
|
|
DlpWriteNetSyncInfoReqHdrType
|
|
hdr; // 0; fixed-size header
|
|
// FIXED SIZE: 24 bytes
|
|
UInt8 syncAddr[2]; // 24; sync IP address/host name -- var size,
|
|
// null-terminated
|
|
} DlpWriteNetSyncInfoReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpReadFeature
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
//
|
|
// Response arguments:
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotFound,
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
#define dlpReadFeatureReqArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadFeatureReqType {
|
|
// OFFSET
|
|
UInt32 dwFtrCreator; // 0; feature creator
|
|
UInt16 wFtrNum; // 4; feature number
|
|
// TOTAL: 6 bytes
|
|
} DlpReadFeatureReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
#define dlpReadFeatureRespArgID dlpFirstArgID
|
|
|
|
typedef struct DlpReadFeatureRespType {
|
|
// OFFSET
|
|
UInt32 dwFeature; // 0; feature value
|
|
// TOTAL: 4 bytes
|
|
} DlpReadFeatureRespType;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpFindDB
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
//
|
|
// Response arguments:
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrNotFound,
|
|
// dlpRespErrParam
|
|
|
|
// Request argument structure:
|
|
//
|
|
|
|
// dlpFindDBByNameReqArgID, dlpFindDBByTypeCreatorReqArgID and dlpFindDBByOpenHandleReqArgID
|
|
// are mutually exclusive
|
|
enum {
|
|
dlpFindDBByNameReqArgID = dlpFirstArgID, // req id for card + name based search
|
|
dlpFindDBByOpenHandleReqArgID, // req id for search given an open db handle
|
|
dlpFindDBByTypeCreatorReqArgID // req id for type + creator based iterative search
|
|
};
|
|
|
|
// Option flags
|
|
#define dlpFindDBOptFlagGetAttributes 0x80 // get database attributes -- this is
|
|
// an option to allow find operations to skip
|
|
// returning this data as a performance optimization
|
|
|
|
#define dlpFindDBOptFlagGetSize 0x40 // get record count and data size also -- this is
|
|
// an option because the operation can take a long
|
|
// time, which we would rather avoid if it is not needed
|
|
|
|
#define dlpFindDBOptFlagGetMaxRecSize 0x20 // get max rec/resource size -- this is
|
|
// an option because the operation can take a long
|
|
// time, which we would rather avoid if it is not needed
|
|
// (dlpFindDBOptFlagGetMaxRecSize is only supported for
|
|
// dlpFindDBByOpenHandleReqArgID)
|
|
|
|
// Request type for dlpdlpFindDBByNameReqArgID:
|
|
typedef struct DlpFindDBByNameReqHdrType {
|
|
// OFFSET
|
|
UInt8 bOptFlags; // 0; bitfield of dlpFindDBOptFlag... flags
|
|
UInt8 bCardNo; // 2; card number to search
|
|
// TOTAL: 4 bytes
|
|
} DlpFindDBByNameReqHdrType;
|
|
|
|
typedef struct DlpFindDBByNameReqType {
|
|
// OFFSET
|
|
DlpFindDBByNameReqHdrType //
|
|
header; // 0; fixed size header
|
|
// FIXED SIZE: 4 bytes
|
|
UInt8 name[2]; // variable size -- zero-terminated database name string
|
|
} DlpFindDBByNameReqType;
|
|
|
|
|
|
// Request type for dlpFindDBByOpenHandleReqArgID:
|
|
typedef struct DlpFindDBByOpenHandleReqType {
|
|
// OFFSET
|
|
UInt8 bOptFlags; // 0; bitfield of dlpFindDBOptFlag... flags
|
|
UInt8 bDbID; // 1; database id returned by dlpOpenDB or dlpCreateDB
|
|
// TOTAL: 2 bytes
|
|
} DlpFindDBByOpenHandleReqType;
|
|
|
|
|
|
// Request type for dlpFindDBByTypeCreatorReqArgID:
|
|
typedef struct DlpFindDBByTypeCreatorReqType {
|
|
// OFFSET
|
|
UInt8 bOptFlags; // 0; bitfield of dlpFindDBOptFlag... flags
|
|
UInt8 bSrchFlags; // 1; bitfield of dlpFindDBSrchFlag... flags
|
|
UInt32 dwType; // 2; db type id (zero = wildcard)
|
|
UInt32 dwCreator; // 6; db creator id (zero = wildcard)
|
|
// TOTAL: 10 bytes
|
|
} DlpFindDBByTypeCreatorReqType;
|
|
|
|
#define dlpFindDBSrchFlagNewSearch 0x80 // set to beging a new search
|
|
#define dlpFindDBSrchFlagOnlyLatest 0x40 // set to search for the latest version
|
|
|
|
|
|
|
|
// Response argument structures for dlpFindDBByNameReqArgID, dlpFindDBByOpenHandleReqArgID and
|
|
// dlpFindDBByTypeCreatorReqArgID (if found):
|
|
//
|
|
enum {
|
|
dlpFindDBBasicRespArgID = dlpFirstArgID, // resp arg id for basic info
|
|
// (if dlpFindDBOptFlagGetAttributes is set)
|
|
dlpFindDBSizeRespArgID // resp arg id for size info
|
|
// (if dlpFindDBOptFlagGetSize or dlpFindDBOptFlagGetMaxRecSize
|
|
// are set)
|
|
};
|
|
|
|
|
|
// dlpFindDBBasicRespArgID (returned only if dlpFindDBOptFlagGetAttributes is set):
|
|
|
|
typedef struct DlpFindDBBasicRespHdrType {
|
|
// OFFSET
|
|
UInt8 bCardNo; // 0; card number of database
|
|
UInt8 bReserved; // 1; RESERVED -- SET TO NULL
|
|
UInt32 dwLocalID; // 2; local id of the database (for internal use)
|
|
UInt32 dwOpenRef; // 6; db open ref of the database if it is currently opened
|
|
// by the caller; zero otherwise (for internal use) can
|
|
// change after read record list
|
|
DlpDBInfoHdrType info; //10; database info (creator, type, flags, etc.) MUST BE LAST FIELD
|
|
// TOTAL: 54 bytes
|
|
} DlpFindDBBasicRespHdrType;
|
|
|
|
typedef struct DlpFindDBBasicRespType {
|
|
// OFFSET
|
|
DlpFindDBBasicRespHdrType //
|
|
header; // 0; fixed-size header
|
|
// FIXED SIZE: 54 bytes
|
|
UInt8 name[2]; // variable size -- zero-terminated database name string
|
|
} DlpFindDBBasicRespType;
|
|
|
|
|
|
|
|
// dlpFindDBSizeRespArgID (returned only if dlpFindDBOptFlagGetSize or dlpFindDBOptFlagGetMaxRecSize is set):
|
|
|
|
typedef struct DlpFindDBSizeRespType {
|
|
// OFFSET
|
|
|
|
// Returned if dlpFindDBOptFlagGetSize is set for all queries:
|
|
// (otherwise, fields are set to zero)
|
|
UInt32 dwNumRecords; // 0; record/resource count
|
|
UInt32 dwTotalBytes; // 4; total bytes used by db
|
|
UInt32 dwDataBytes; // 8; bytes used for data
|
|
|
|
// Returned if dlpFindDBOptFlagGetSize is set for dlpFindDBByOpenHandleReqArgID only:
|
|
// (otherwise, fields are set to zero)
|
|
UInt32 dwAppBlkSize; //12; size of app info block size (for
|
|
// dlpFindDBByOpenHandleReqArgID only)
|
|
UInt32 dwSortBlkSize; //16; size of sort info block size(for
|
|
// dlpFindDBByOpenHandleReqArgID only)
|
|
//
|
|
// Returned if dlpFindDBOptFlagGetMaxRecSize is set for dlpFindDBByOpenHandleReqArgID only:
|
|
// (otherwise, field is set to zero)
|
|
UInt32 dwMaxRecSize; //20; size of largest record or resource in the database (for
|
|
// dlpFindDBByOpenHandleReqArgID + dlpFindDBOptFlagGetMaxRecSize only)
|
|
// TOTAL: 24 bytes
|
|
} DlpFindDBSizeRespType;
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// dlpSetDBInfo
|
|
//////////////////////////////////////////////////////////////////////////
|
|
// Request arguments:
|
|
//
|
|
// Response arguments:
|
|
//
|
|
// Possible error codes
|
|
// dlpRespErrSystem,
|
|
// dlpRespErrParam,
|
|
// dlpRespErrNotFound
|
|
// dlpRespErrNotEnoughSpace
|
|
// dlpRespErrNotSupported
|
|
// dlpRespErrReadOnly
|
|
// dlpRespErrNoneOpen
|
|
|
|
// Request argument structure:
|
|
//
|
|
|
|
enum {
|
|
dlpSetDBInfoReqArgID = dlpFirstArgID
|
|
};
|
|
|
|
|
|
typedef struct DlpSetDBInfoReqHdrType {
|
|
// OFFSET
|
|
UInt8 dbID; // 0; database id returned by dlpOpenDB or dlpCreateDB
|
|
UInt8 bReserved; // 1; RESERVED -- SET TO NULL
|
|
UInt16 wClrDbFlags; // 2; flags to clear; allowed DB flags: dlpDBFlagAppInfoDirty,
|
|
// dlpDBFlagBackup, dlpDBFlagOKToInstallNewer,
|
|
// dlpDBFlagResetAfterInstall, dlpDBFlagCopyPrevention;
|
|
// 0 = don't change
|
|
UInt16 wSetDbFlags; // 4; flags to set; allowed DB flags: dlpDBFlagAppInfoDirty,
|
|
// dlpDBFlagBackup, dlpDBFlagOKToInstallNewer,
|
|
// dlpDBFlagResetAfterInstall, dlpDBFlagCopyPrevention;
|
|
// 0 = don't change
|
|
UInt16 wDbVersion; // 6; database version; dlpSetDBInfoNoVerChange = don't change
|
|
DlpDateTimeType crDate; // 8; creation date; zero year = don't change
|
|
DlpDateTimeType modDate; //16; modification date; zero year = don't change
|
|
DlpDateTimeType bckUpDate; //24; backup date; zero year = don't change
|
|
UInt32 dwType; //32; database type id; zero = don't change
|
|
UInt32 dwCreator; //36; database creator id; zero = don't change
|
|
// TOTAL: 40 bytes
|
|
} DlpSetDBInfoReqHdrType;
|
|
|
|
#define dlpSetDBInfoNoVerChange 0xFFFF
|
|
|
|
typedef struct DlpSetDBInfoReqType {
|
|
// OFFSET
|
|
DlpSetDBInfoReqHdrType //
|
|
header; // 0; fixed size header
|
|
// FIXED SIZE: 40 bytes
|
|
UInt8 name[2]; // variable size -- zero-terminated database name string
|
|
} DlpSetDBInfoReqType;
|
|
|
|
|
|
// Response argument structure:
|
|
//
|
|
// none.
|
|
|
|
|
|
|
|
/************************************************************
|
|
* Macros
|
|
*************************************************************/
|
|
|
|
|
|
#endif // __DLCOMMON_H__
|
|
|