home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Amiga 12 / MA_Cover_12.iso / libs / palmlink / developer / palmlink.doc < prev   
Encoding:
Text File  |  1999-04-24  |  89.1 KB  |  3,300 lines

  1. TABLE OF CONTENTS
  2.  
  3. palmlink.library/--background--
  4. palmlink.library/DLP_AddSyncLogEntry
  5. palmlink.library/DLP_CleanUpDatabase
  6. palmlink.library/DLP_CloseAllDB
  7. palmlink.library/DLP_CloseDB
  8. palmlink.library/DLP_CountDBEntries
  9. palmlink.library/DLP_CreateDB
  10. palmlink.library/DLP_DeleteCategory
  11. palmlink.library/DLP_DeleteDB
  12. palmlink.library/DLP_DeleteRecord
  13. palmlink.library/DLP_DeleteResource
  14. palmlink.library/DLP_EndOfSync
  15. palmlink.library/DLP_GetDBInfo
  16. palmlink.library/DLP_GetNetSyncInfo
  17. palmlink.library/DLP_GetRecordIDList
  18. palmlink.library/DLP_GetStorageInfo
  19. palmlink.library/DLP_GetSysInfo
  20. palmlink.library/DLP_GetSysTime
  21. palmlink.library/DLP_GetUserInfo
  22. palmlink.library/DLP_MoveCategory
  23. palmlink.library/DLP_OpenConduit
  24. palmlink.library/DLP_OpenDB
  25. palmlink.library/DLP_ReadAppBlock
  26. palmlink.library/DLP_ReadAppPreference
  27. palmlink.library/DLP_ReadNextCatRecord
  28. palmlink.library/DLP_ReadNextModifiedCatRecord
  29. palmlink.library/DLP_ReadRecordByID
  30. palmlink.library/DLP_ReadRecordByIndex
  31. palmlink.library/DLP_ReadResourceByIndex
  32. palmlink.library/DLP_ReadResourceByType
  33. palmlink.library/DLP_ReadSortBlock
  34. palmlink.library/DLP_ResetDBIndex
  35. palmlink.library/DLP_ResetLastSyncPC
  36. palmlink.library/DLP_ResetSyncFlags
  37. palmlink.library/DLP_ResetSystem
  38. palmlink.library/DLP_SetNetSyncInfo
  39. palmlink.library/DLP_SetSysTime
  40. palmlink.library/DLP_SetUserInfo
  41. palmlink.library/DLP_WriteAppBlock
  42. palmlink.library/DLP_WriteAppPreference
  43. palmlink.library/DLP_WriteRecord
  44. palmlink.library/DLP_WriteResource
  45. palmlink.library/DLP_WriteSortBlock
  46. palmlink.library/PL_Accept
  47. palmlink.library/PL_AddRexxHandle
  48. palmlink.library/PL_CloseSocket
  49. palmlink.library/PL_CMPAbort
  50. palmlink.library/PL_CMPInit
  51. palmlink.library/PL_CMPRead
  52. palmlink.library/PL_CMPWakeUp
  53. palmlink.library/PL_Connect
  54. palmlink.library/PL_DeleteRexxHandle
  55. palmlink.library/PL_DLPInit
  56. palmlink.library/PL_DLPRead
  57. palmlink.library/PL_DLPSend
  58. palmlink.library/PL_DLPTstWrite
  59. palmlink.library/PL_DLPWrite
  60. palmlink.library/PL_DLPWriteByte
  61. palmlink.library/PL_DLPWriteLong
  62. palmlink.library/PL_DLPWriteWord
  63. palmlink.library/PL_Explain
  64. palmlink.library/PL_FileAddRecord
  65. palmlink.library/PL_FileAddResorce
  66. palmlink.library/PL_FileClose
  67. palmlink.library/PL_FileGetAppInfo
  68. palmlink.library/PL_FileGetDBInfo
  69. palmlink.library/PL_FileGetSortInfo
  70. palmlink.library/PL_FileInstall
  71. palmlink.library/PL_FileMerge
  72. palmlink.library/PL_FileOpen
  73. palmlink.library/PL_FileReadRecord
  74. palmlink.library/PL_FileReadRecordID
  75. palmlink.library/PL_FileReadResorce
  76. palmlink.library/PL_FileRetrieve
  77. palmlink.library/PL_FileSetAppInfo
  78. palmlink.library/PL_FileSetDBInfo
  79. palmlink.library/PL_FileSetSortInfo
  80. palmlink.library/PL_FileUsedID
  81. palmlink.library/PL_FindRexxHandle
  82. palmlink.library/PL_LastError
  83. palmlink.library/PL_OpenSocket
  84. palmlink.library/PL_PADPRead
  85. palmlink.library/PL_PADPWrite
  86. palmlink.library/PL_RawRead
  87. palmlink.library/PL_RawSetRate
  88. palmlink.library/PL_RawWrite
  89. palmlink.library/PL_Read
  90. palmlink.library/PL_SLPRead
  91. palmlink.library/PL_SLPWrite
  92. palmlink.library/PL_Tickle
  93. palmlink.library/PL_Write
  94.  
  95. palmlink.library/--background--
  96.  
  97.    NAME
  98.         palmlink.library
  99.  
  100.    DESCRIPTION
  101.         This library provides a connection to 3Com's Palm PDA with PalmOS
  102.         2.0 or later. With appropriate software, you are now able to use
  103.         the HotSync feature on your Amiga as well.
  104.  
  105.    REQUIREMENTS
  106.         PalmLink requires at least AmigaOS V2.04, a 68020 processor, and
  107.         a Palm organizer connected to any serial port of the Amiga. An
  108.         68000 version is also available.
  109.  
  110.         The palmlink.library requires at least 8192 byte of Stack, so
  111.         be prepared! Currently, you must call all function from the same
  112.         task that opened the socket.
  113.  
  114.    CONSTRUCTION
  115.         The lowest layer of PalmLink is the serial device itself. It is
  116.         controlled by all PL_RAW commands.
  117.  
  118.         Basing on the serial layer, the SLP (Serial Link Protocol) handles
  119.         the source and destination ID, and the message type. The maximum
  120.         size of SLP messages is 1024 byte.
  121.  
  122.         The PADP (Packet Assembly Disassembly Protocol) splits or joins
  123.         the data packets, respectively. It also attaches a transaction
  124.         ID so the packets can be joined properly. Anyhow, even the PADP
  125.         data packages are limited to about 65536 byte.
  126.  
  127.         The CMP (Connection Management Protocol) controls the connection
  128.         between the Palm Pilot and the Amiga, as e.g. the baud rate used.
  129.  
  130.         Until here, the client usually does not need to call any functions.
  131.         The main API of the library consists of connection and data transfer
  132.         functions. They are based on BSD socket like functions, though they
  133.         are quite 'Amigized'.
  134.  
  135.         A high level protocol is the SYSPKT protocol. It is used for
  136.         debugging purposes. Currently it is not implemented to palmlink.
  137.         I will only implement it upon significant request.
  138.  
  139.         The client will use the DLP (Desktop Link Protocol) in most cases.
  140.         With this protocol, the Pilot's data base can be accessed and
  141.         manipulated. Basing on this, the client can do a backup of all
  142.         data as well as 'HotSync' the Scheduler, ToDo list, and other
  143.         data bases.
  144.  
  145.         Additionally, there are some functions that provide access to '.prc'
  146.         and '.pdb' files as data bases.
  147.  
  148.         For ARexx library programmers, basic handle managment is provided.
  149.  
  150.    BUGS
  151.         Currently, palmlink calls its own functions by a direct call. Thus,
  152.         patching library functions does not show any effect. Please don't
  153.         patch anything until further notice.
  154.  
  155.         The provided pointers are *not* checked against NULL yet. I strongly
  156.         suggest to use Enforcer during development.
  157.  
  158.         PL_Connect() still does not work. I'm currently evaluating this bug.
  159.  
  160.    IMPORTANT
  161.         · Make sure that the stack is large enough (8192 byte at least)
  162.         · Currently, you MUST use all functions within the same task that
  163.           opened the socket to the Palm organizer.
  164.         · Do not manipulate READ ONLY fields!
  165.         · Do not use PRIVATE stuff!
  166.         · Do not assume a special value for TRUE. TRUE is anything except 0.
  167.  
  168.    COPYRIGHT
  169.         The palmlink.library is Copyright (C) 1998-99 by Richard Körber.
  170.         All rights reserved. Please read the main guide for further
  171.         information and the copyright note.
  172.  
  173.         palmlink.library is MailWare. You don't need to pay any fees, though
  174.         you must send me an e-mail if you use it.
  175.  
  176.         If it is used in commercial software (ShareWare is commercial as
  177.         well), you must provide me with a full featured and registered
  178.         release of your software, along with all future updates, as long
  179.         as you use the palmlink.library, and without any charge.
  180.  
  181.         E-Mail:  richard.koerber@koeln.netsurf.de
  182.                  shred@eratosthenes.starfleet.de
  183.  
  184.         WWW:     http://shredzone.home.pages.de/
  185.  
  186.    TRADEMARKS
  187.         Palm Pilot, Palm III and PalmOS are trademarks of 3Com.
  188.         3Com and HotSync are registered trademarks of 3Com.
  189.  
  190. palmlink.library/DLP_AddSyncLogEntry
  191.  
  192.    NAME
  193.         DLP_AddSyncLogEntry - Add an entry to the HotSync log
  194.  
  195.    SYNOPSIS
  196.         Success = DLP_AddSyncLogEntry(Socket,Entry)
  197.           D0.l                         A0.l  A1.l
  198.  
  199.         int DLP_AddSyncLogEntry(APTR,STRPTR);
  200.  
  201.    FUNCTION
  202.         Add an entry to the HotSync log. The user can read the last HotSync
  203.         log with the HotSync tool of the Palm Pilot.
  204.  
  205.    INPUTS
  206.         Socket        -- (APTR) Socket
  207.         Entry         -- (STRPTR) String to be added
  208.  
  209.    RESULT
  210.         Success       -- (int) TRUE: Entry has been added
  211.  
  212.    NOTE
  213.  
  214.    BUGS
  215.  
  216.    SEE ALSO
  217.  
  218.  
  219. palmlink.library/DLP_CleanUpDatabase
  220.  
  221.    NAME
  222.         DLP_CleanUpDatabase - Clean up the database
  223.  
  224.    SYNOPSIS
  225.         Success = DLP_CleanUpDatabase(Socket,DBHandle)
  226.           D0.l                         A0.l    D0.l
  227.  
  228.         int DLP_CleanUpDatabase(APTR,LONG);
  229.  
  230.    FUNCTION
  231.         Clean up the database.
  232.  
  233.    INPUTS
  234.         Socket        -- (APTR) Socket
  235.         DBHandle      -- (LONG) Handle of the database to be cleaned.
  236.  
  237.    RESULT
  238.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  239.                 error occured (see PL_LastError()).
  240.  
  241.    NOTE
  242.  
  243.    BUGS
  244.  
  245.    SEE ALSO
  246.  
  247.  
  248. palmlink.library/DLP_CloseAllDB
  249.  
  250.    NAME
  251.         DLP_CloseAllDB - Close all opened databases
  252.  
  253.    SYNOPSIS
  254.         Success = DLP_CloseAllDB(Socket)
  255.           D0.l                    A0.l
  256.  
  257.         int DLP_CloseAllDB(APTR);
  258.  
  259.    FUNCTION
  260.         Closes all databases previously opened.
  261.  
  262.    INPUTS
  263.         Socket        -- (APTR) Socket
  264.  
  265.    RESULT
  266.         Success       -- (int) TRUE: all DB have been closed successfully
  267.  
  268.    NOTE
  269.  
  270.    BUGS
  271.  
  272.    SEE ALSO
  273.         DLP_CloseDB()
  274.  
  275.  
  276. palmlink.library/DLP_CloseDB
  277.  
  278.    NAME
  279.         DLP_CloseDB - Close a database
  280.  
  281.    SYNOPSIS
  282.         Success = DLP_CloseDB(Socket,DBHandle)
  283.           D0.l                 A0.l    D0.l
  284.  
  285.         int DLP_CloseDB(APTR,LONG);
  286.  
  287.    FUNCTION
  288.         Close a database.
  289.  
  290.    INPUTS
  291.         Socket        -- (APTR) Socket
  292.         DBHandle      -- (LONG) Handle of the database to close
  293.  
  294.    RESULT
  295.         Success       -- (int) TRUE: DB has been closed successfully
  296.  
  297.    NOTE
  298.  
  299.    BUGS
  300.  
  301.    SEE ALSO
  302.         DLP_OpenDB(), DLP_CreateDB(), DLP_DeleteDB(), DLP_CloseAllDB()
  303.  
  304.  
  305. palmlink.library/DLP_CountDBEntries
  306.  
  307.    NAME
  308.         DLP_CountDBEntries - Count the entries of a database
  309.  
  310.    SYNOPSIS
  311.         Number = DLP_CountDBEntries(Socket,DBHandle)
  312.          D0.l                        A0.l    D0.l
  313.  
  314.         LONG DLP_CountDBEntries(APTR,LONG);
  315.  
  316.    FUNCTION
  317.         Count the number of entries of a database. Use this function e.g.
  318.         if you want to read all entries of the database.
  319.  
  320.    INPUTS
  321.         Socket        -- (APTR) Socket
  322.         DBHandle      -- (LONG) Handle of the database to count
  323.  
  324.    RESULT
  325.         Number        -- (LONG) Number of entries, or -1 if an error
  326.                 occured (see PL_LastError()).
  327.  
  328.    NOTE
  329.  
  330.    BUGS
  331.  
  332.    SEE ALSO
  333.  
  334.  
  335. palmlink.library/DLP_CreateDB
  336.  
  337.    NAME
  338.         DLP_CreateDB - Create a new database
  339.  
  340.    SYNOPSIS
  341.         DBHandle = DLP_CreateDB(Socket,CardNo,Creator,Type,Flags,Version,Name)
  342.           D0.l                   A0.l   D0.b   D1.l   D2.l  D3.w  D4.w   A1.l
  343.  
  344.         LONG DLP_CreateDB(APTR,UBYTE,ULONG,ULONG,UWORD,UWORD,STRPTR);
  345.  
  346.    FUNCTION
  347.         Create a new database. The database handle is returned.
  348.  
  349.    INPUTS
  350.         Socket        -- (APTR) Socket
  351.         CardNo        -- (UBYTE) Card number of the database (usually 0)
  352.         Creator       -- (ULONG) ID of the DB creator. For own developments,
  353.                 you must register an ID from 3Com (see their web page).
  354.         Type          -- (ULONG) Type ID of the DB.
  355.         Flags         -- (UWORD) Flags (see includes)
  356.         Version       -- (UWORD) Version of the database
  357.         Name          -- (STRPTR) Name of the database to create
  358.  
  359.    RESULT
  360.         DBHandle      -- (LONG) Handle of the created data base, or -1
  361.                 if an error occured (see PL_LastError()).
  362.  
  363.    NOTE
  364.  
  365.    BUGS
  366.  
  367.    SEE ALSO
  368.         DLP_OpenDB(), DLP_DeleteDB(), DLP_CloseDB()
  369.  
  370.  
  371. palmlink.library/DLP_DeleteCategory
  372.  
  373.    NAME
  374.         DLP_DeleteCategory - Delete a record category from the database
  375.  
  376.    SYNOPSIS
  377.         Success = DLP_DeleteCategory(Socket,DBHandle,CatID)
  378.           D0.l                        A0.l    D0.l    D1.b
  379.  
  380.         int DLP_DeleteCategory(APTR,ULONG,BOOL);
  381.  
  382.    FUNCTION
  383.         Delete a record category from the database.
  384.  
  385.    INPUTS
  386.         Socket        -- (APTR) Socket
  387.         DBHandle      -- (LONG) Database handle
  388.         CatID         -- (UBYTE) Category ID to delete
  389.  
  390.    RESULT
  391.         Success       -- (int) TRUE: Category has been deleted.
  392.  
  393.    NOTE
  394.         This function requires PalmOS 2.0 or higher. There is workaround
  395.         for OS 1.0, but since it is quite outdated, I see no reason to
  396.         implement it. If you require it, please get in contact with me.
  397.  
  398.    BUGS
  399.  
  400.    SEE ALSO
  401.  
  402.  
  403. palmlink.library/DLP_DeleteDB
  404.  
  405.    NAME
  406.         DLP_DeleteDB - Delete a database
  407.  
  408.    SYNOPSIS
  409.         Success = DLP_DeleteDB(Socket,CardNo,Name)
  410.           D0.l                  A0.l   D0.b  A1.l
  411.  
  412.         int DLP_DeleteDB(APTR,UBYTE,STRPTR);
  413.  
  414.    FUNCTION
  415.         Delete a database.
  416.  
  417.    INPUTS
  418.         Socket        -- (APTR) Socket
  419.         CardNo        -- (UBYTE) Card number where the database is stored
  420.         Name          -- (STRPTR) Name of the database to be deleted
  421.  
  422.    RESULT
  423.         Success       -- (int) TRUE: DB has been deleted successfully
  424.  
  425.    NOTE
  426.  
  427.    BUGS
  428.  
  429.    SEE ALSO
  430.         DLP_OpenDB(), DLP_CreateDB(), DLP_CloseDB()
  431.  
  432.  
  433. palmlink.library/DLP_DeleteRecord
  434.  
  435.    NAME
  436.         DLP_DeleteRecord - Delete a record from the database
  437.  
  438.    SYNOPSIS
  439.         Success = DLP_DeleteRecord(Socket,DBHandle,All,ID)
  440.           D0.l                      A0.l   D0.l    D1.b D2.l
  441.  
  442.         int DLP_DeleteRecord(APTR,ULONG,BOOL,ULONG);
  443.  
  444.    FUNCTION
  445.         Delete a record from the database.
  446.  
  447.    INPUTS
  448.         Socket        -- (APTR) Socket
  449.         DBHandle      -- (LONG) Database handle
  450.         All           -- (BOOL) True: delete *all* records of this database
  451.         ID            -- (ULONG) Record ID to delete
  452.  
  453.    RESULT
  454.         Success       -- (int) TRUE: Record has been deleted.
  455.  
  456.    NOTE
  457.  
  458.    BUGS
  459.  
  460.    SEE ALSO
  461.  
  462.  
  463. palmlink.library/DLP_DeleteResource
  464.  
  465.    NAME
  466.         DLP_DeleteResource - Delete a resource from the database
  467.  
  468.    SYNOPSIS
  469.         Success = DLP_DeleteResource(Socket,DBHandle,All,Type,ID)
  470.           D0.l                        A0.l   D0.l    D1.b D2.l D3.w
  471.  
  472.         int DLP_DeleteResource(APTR,ULONG,BOOL,ULONG,UWORD);
  473.  
  474.    FUNCTION
  475.         Delete a resource from the database.
  476.  
  477.    INPUTS
  478.         Socket        -- (APTR) Socket
  479.         DBHandle      -- (LONG) Database handle
  480.         All           -- (BOOL) True: delete *all* resources of this database
  481.         Type          -- (ULONG) Resource Type
  482.         ID            -- (ULONG) Record ID
  483.  
  484.    RESULT
  485.         Success       -- (int) TRUE: Resource has been deleted.
  486.  
  487.    NOTE
  488.  
  489.    BUGS
  490.  
  491.    SEE ALSO
  492.  
  493.  
  494. palmlink.library/DLP_EndOfSync
  495.  
  496.    NAME
  497.         DLP_EndOfSync - Terminate all database accesses
  498.  
  499.    SYNOPSIS
  500.         Success = DLP_EndOfSync(Socket,Status)
  501.           D0.l                   A0.l   D0.w
  502.  
  503.         int DLP_EndOfSync(APTR,UWORD);
  504.  
  505.    FUNCTION
  506.         Closes the Pilot database. After you called this function, you
  507.         should close the connection.
  508.  
  509.         *NEVER* forget to call DLP_EndOfSync() when you called
  510.         DLP_OpenConduit(). PalmLink won't do this for you.
  511.  
  512.    INPUTS
  513.         Socket        -- (APTR) Socket
  514.         Status        -- (UWORD) Status code
  515.  
  516.    RESULT
  517.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  518.                 error occured (see PL_LastError()).
  519.  
  520.    NOTE
  521.  
  522.    BUGS
  523.  
  524.    SEE ALSO
  525.         DLP_OpenConduit()
  526.  
  527.  
  528. palmlink.library/DLP_GetDBInfo
  529.  
  530.    NAME
  531.         DLP_GetDBInfo - Get information about the database
  532.  
  533.    SYNOPSIS
  534.         Success = DLP_GetDBInfo(Socket,CardNo,Flags,Index,Info)
  535.           D0.l                   A0.l   D0.b   D1.b  D2.w A1.l
  536.  
  537.         int DLP_GetDBInfo(APTR,UBYTE,UBYTE,UWORD,struct DLP_DBInfo *);
  538.  
  539.    FUNCTION
  540.         The passed DLP_DBInfo structure is filled with information
  541.         about the database with the number provided in Start.
  542.  
  543.    INPUTS
  544.         Socket        -- (APTR) Socket
  545.         CardNo        -- (UBYTE) Card to select (usually 0)
  546.         Flags         -- (UBYTE) Access flags (RAM or ROM), see
  547.                 include file.
  548.         Index         -- (UWORD) Database number to get information
  549.                 about. Start with 0, then proceed with Info.Index+1
  550.                 of each returned data base.
  551.         Info          -- (struct DLP_DBInfo *) DBInfo structure
  552.                 to be filled
  553.  
  554.    RESULT
  555.         Success       -- (int) TRUE: Information has been read.
  556.  
  557.    NOTE
  558.  
  559.    BUGS
  560.  
  561.    SEE ALSO
  562.  
  563.  
  564. palmlink.library/DLP_GetNetSyncInfo
  565.  
  566.    NAME
  567.         DLP_GetNetSyncInfo - Get information about net sync
  568.  
  569.    SYNOPSIS
  570.         Success = DLP_GetNetSyncInfo(Socket,NetSync)
  571.           D0.l                        A0.l   A1.l
  572.  
  573.         int DLP_GetNetSyncInfo(APTR,struct DLP_NetSyncInfo *);
  574.  
  575.    FUNCTION
  576.         Get information about net sync into the DLP_NetSyncInfo structure.
  577.  
  578.    INPUTS
  579.         Socket        -- (APTR) Socket
  580.         NetSync       -- (struct DLP_NetSyncInfo *) Buffer space for the
  581.                 NetSync structure.
  582.  
  583.    RESULT
  584.         Success       -- (int) TRUE: NetSyncInfo has been get.
  585.  
  586.    NOTE
  587.         This function requires PalmOS 2.0 or higher. There is workaround
  588.         for OS 1.0, but since it is quite outdated, I see no reason to
  589.         implement it. If you require it, please get in contact with me.
  590.  
  591.    BUGS
  592.  
  593.    SEE ALSO
  594.         DLP_SetNetSyncInfo()
  595.  
  596.  
  597. palmlink.library/DLP_GetRecordIDList
  598.  
  599.    NAME
  600.         DLP_GetRecordIDList - Get a list of all record IDs of this database
  601.  
  602.    SYNOPSIS
  603.         Number = DLP_GetRecordIDList(Socket,DBHandle,Sort,Start,Max,IDs)
  604.          D0.l                         A0.l    D0.l   D1.w D2.w  D3.w A1.l
  605.  
  606.         LONG DLP_GetRecordIDList(APTR,LONG,BOOL,UWORD,UWORD,ULONG *);
  607.  
  608.    FUNCTION
  609.         Get a list of all record IDs of this database.
  610.  
  611.    INPUTS
  612.         Socket        -- (APTR) Socket
  613.         DBHandle      -- (LONG) Database handle
  614.         Sort          -- (BOOL) The list is sorted
  615.         Start         -- (UWORD) Start record index
  616.         Max           -- (UWORD) Maximum number of entries that fit into
  617.                 the ID table
  618.         IDs           -- (ULONG *) ID table that will contain the record
  619.                 IDs after this call
  620.  
  621.    RESULT
  622.         Number        -- (LONG) Number of IDs that were written into the
  623.                 table, or -1 on error.
  624.  
  625.    NOTE
  626.  
  627.    BUGS
  628.  
  629.    SEE ALSO
  630.  
  631.  
  632. palmlink.library/DLP_GetStorageInfo
  633.  
  634.    NAME
  635.         DLP_GetStorageInfo - Get information about Pilot's memory
  636.  
  637.    SYNOPSIS
  638.         Success = DLP_GetStorageInfo(Socket,CardNo,Info)
  639.           D0.l                        A0.l   D0.b  A1.l
  640.  
  641.         int DLP_GetStorageInfo(APTR,UBYTE,struct DLP_StorageInfo *);
  642.  
  643.    FUNCTION
  644.         The passed DLP_StorageInfo structure is filled with information
  645.         about the Pilot's built-in memory card.
  646.  
  647.    INPUTS
  648.         Socket        -- (APTR) Socket
  649.         CardNo        -- (UBYTE) Card Nr. to be read. Start with 0, then
  650.                 iterate with DLP_StorageInfo.cardNo+1.
  651.         Info          -- (struct DLP_StorageInfo *) StorageInfo structure
  652.                 to be filled
  653.  
  654.    RESULT
  655.         Success       -- (int) TRUE: Information has been read.
  656.  
  657.    NOTE
  658.  
  659.    BUGS
  660.  
  661.    SEE ALSO
  662.  
  663.  
  664. palmlink.library/DLP_GetSysInfo
  665.  
  666.    NAME
  667.         DLP_GetSysInfo - Get information about the Pilot
  668.  
  669.    SYNOPSIS
  670.         Success = DLP_GetSysInfo(Socket,Info)
  671.           D0.l                    A0.l  A1.l
  672.  
  673.         int DLP_GetSysInfo(APTR,struct DLP_SysInfo *);
  674.  
  675.    FUNCTION
  676.         The passed DLP_SysInfo structure is filled with information
  677.         about the Pilot's built-in memory cards.
  678.  
  679.    INPUTS
  680.         Socket        -- (APTR) Socket
  681.         Info          -- (struct DLP_SysInfo *) SysInfo structure
  682.                 to be filled
  683.  
  684.    RESULT
  685.         Success       -- (int) TRUE: Information has been read.
  686.  
  687.    NOTE
  688.  
  689.    BUGS
  690.  
  691.    SEE ALSO
  692.  
  693.  
  694. palmlink.library/DLP_GetSysTime
  695.  
  696.    NAME
  697.         DLP_GetSysTime - Get the Pilot system time
  698.  
  699.    SYNOPSIS
  700.         Success = DLP_GetSysTime(Socket,Time)
  701.           D0.l                    A0.l  A1.l
  702.  
  703.         int DLP_GetSysTime(APTR,struct DLP_SysTime *);
  704.  
  705.    FUNCTION
  706.         The passed DLP_SysTime structure is filled with the current
  707.         time of the Pilot's internal clock.
  708.  
  709.    INPUTS
  710.         Socket        -- (APTR) Socket
  711.         Time          -- (struct DLP_SysTime *) Time structure to be filled
  712.  
  713.    RESULT
  714.         Success       -- (int) TRUE: Time has been read.
  715.  
  716.    NOTE
  717.  
  718.    BUGS
  719.  
  720.    SEE ALSO
  721.         DLP_SetSysTime()
  722.  
  723.  
  724. palmlink.library/DLP_GetUserInfo
  725.  
  726.    NAME
  727.         DLP_GetUserInfo - Get information about the Pilot user
  728.  
  729.    SYNOPSIS
  730.         Success = DLP_GetUserInfo(Socket,User)
  731.           D0.l                     A0.l  A1.l
  732.  
  733.         int DLP_GetUserInfo(APTR,struct DLP_UserInfo *);
  734.  
  735.    FUNCTION
  736.         Get information about the Pilot user (most probably you ;-)
  737.         into the DLP_UserInfo structure.
  738.  
  739.    INPUTS
  740.         Socket        -- (APTR) Socket
  741.         User          -- (struct DLP_UserInfo *) Buffer space for
  742.                 the UserInfo.
  743.  
  744.    RESULT
  745.         Success       -- (int) TRUE: UserInfo has been get.
  746.  
  747.    NOTE
  748.  
  749.    BUGS
  750.  
  751.    SEE ALSO
  752.         DLP_SetUserInfo()
  753.  
  754.  
  755. palmlink.library/DLP_MoveCategory
  756.  
  757.    NAME
  758.         DLP_MoveCategory - Change a record category ID
  759.  
  760.    SYNOPSIS
  761.         Success = DLP_MoveCategory(Socket,DBHandle,OldID,NewID)
  762.          D0.l                       A0.l    D0.l    D1.b  D2.b
  763.  
  764.         int DLP_MoveCategory(APTR,LONG,UBYTE,UBYTE);
  765.  
  766.    FUNCTION
  767.         Changes a record cateogry ID of the selected database to the new
  768.         ID.
  769.  
  770.    INPUTS
  771.         Socket        -- (APTR) Socket
  772.         DBHandle      -- (LONG) Handle of the database
  773.         OldID         -- (UBYTE) Old record category ID
  774.         NewID         -- (UBYTE) New record category ID
  775.  
  776.    RESULT
  777.         Success       -- (int) TRUE: changed successfully
  778.  
  779.    NOTE
  780.  
  781.    BUGS
  782.  
  783.    SEE ALSO
  784.  
  785.  
  786. palmlink.library/DLP_OpenConduit
  787.  
  788.    NAME
  789.         DLP_OpenConduit - Initialize a database access
  790.  
  791.    SYNOPSIS
  792.         Success = DLP_OpenConduit(Socket)
  793.           D0.l                     A0.l
  794.  
  795.         int DLP_OpenConduit(APTR);
  796.  
  797.    FUNCTION
  798.         Open the Pilot database for access. You must call this function
  799.         once, before you call any other DLP_* function.
  800.  
  801.    INPUTS
  802.         Socket        -- (APTR) Socket
  803.  
  804.    RESULT
  805.         Success       -- (int) FALSE: The Conduit couldn't be opened
  806.                 (see PL_LastError()).
  807.  
  808.    NOTE
  809.  
  810.    BUGS
  811.  
  812.    SEE ALSO
  813.         DLP_EndOfSync()
  814.  
  815.  
  816. palmlink.library/DLP_OpenDB
  817.  
  818.    NAME
  819.         DLP_OpenDB - Open an existing database
  820.  
  821.    SYNOPSIS
  822.         DBHandle = DLP_OpenDB(Socket,CardNo,Mode,Name)
  823.           D0.l                 A0.l   D0.b  D1.b A1.l
  824.  
  825.         LONG DLP_OpenDB(APTR,UBYTE,UBYTE,STRPTR);
  826.  
  827.    FUNCTION
  828.         Open an existing database with the name Name and mode Mode. The
  829.         database handle is returned.
  830.  
  831.    INPUTS
  832.         Socket        -- (APTR) Socket
  833.         CardNo        -- (UBYTE) Card number of the database (usually 0)
  834.         Mode          -- (UBYTE) Access mode (see includes)
  835.         Name          -- (STRPTR) Name of the database to open
  836.  
  837.    RESULT
  838.         DBHandle      -- (LONG) Handle of the opened data base, or -1
  839.                 if an error occured (see PL_LastError()).
  840.  
  841.    NOTE
  842.  
  843.    BUGS
  844.  
  845.    SEE ALSO
  846.         DLP_CreateDB(), DLP_DeleteDB(), DLP_CloseDB()
  847.  
  848.  
  849. palmlink.library/DLP_ReadAppBlock
  850.  
  851.    NAME
  852.         DLP_ReadAppBlock - Read an application block
  853.  
  854.    SYNOPSIS
  855.         Length = DLP_ReadAppBlock(Socket,DBHandle,Offset,Buffer,Length)
  856.           D0.l                     A0.l    D0.l    D1.w   A1.l   D2.w
  857.  
  858.         LONG DLP_ReadAppBlock(APTR,LONG,UWORD,APTR,UWORD);
  859.  
  860.    FUNCTION
  861.         Read the application block of the database.
  862.  
  863.    INPUTS
  864.         Socket        -- (APTR) Socket
  865.         DBHandle      -- (LONG) Database handle
  866.         Offset        -- (UWORD) Offset into the application block
  867.         Buffer        -- (APTR) Buffer for the application block
  868.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  869.                 size is 65535 byte.
  870.  
  871.    RESULT
  872.         Length        -- (LONG) AppBlock bytes that were really read, or -1 if
  873.                 an error occured.
  874.  
  875.    NOTE
  876.  
  877.    BUGS
  878.  
  879.    SEE ALSO
  880.  
  881.  
  882. palmlink.library/DLP_ReadAppPreference
  883.  
  884.    NAME
  885.         DLP_ReadAppPreference - Read the preference of an application
  886.  
  887.    SYNOPSIS
  888.         Length = DLP_ReadAppPreference(Socket,Creator,ID,Saved,MaxSize,Buffer,Size,Version)
  889.          D0.l                           A0.l   D0.l  D1.w D2.w  D3.w    A1.l  A2.l   A3.l
  890.  
  891.         LONG DLP_ReadAppPreference(APTR,ULONG,UWORD,BOOL,UWORD,APTR,UWORD *,UWORD *);
  892.  
  893.    FUNCTION
  894.         Read the preferences of an application. You can choose between the
  895.         saved and the temporary version of the preference.
  896.  
  897.    INPUTS
  898.         Socket        -- (APTR) Socket
  899.         Creator       -- (ULONG) Creator of the application
  900.         ID            -- (UWORD) ID number of the preference (lets an
  901.                 application have multiple preferences)
  902.         Saved         -- (BOOL) TRUE: use the saved preferences, FALSE: use
  903.                 the current preferences.
  904.         MaxSize       -- (UWORD) Size of the buffer
  905.         Buffer        -- (APTR) Buffer where the preferences are stored
  906.         Size          -- (UWORD *) If a pointer is provided, the size of the
  907.                 preference block is stored there. You may provide NULL.
  908.         Version       -- (UWORD *) If a pointer is provided, the version of
  909.                 the preference block is stored there. You may provide NULL.
  910.  
  911.    RESULT
  912.         Length        -- (LONG) Number of bytes that were really read, or -1
  913.                 if an error occured.
  914.  
  915.    NOTE
  916.         This function requires PalmOS 2.0 or higher. There is workaround
  917.         for OS 1.0, but since it is quite outdated, I see no reason to
  918.         implement it. If you require it, please get in contact with me.
  919.  
  920.    BUGS
  921.  
  922.    SEE ALSO
  923.  
  924.  
  925. palmlink.library/DLP_ReadNextCatRecord
  926.  
  927.    NAME
  928.         DLP_ReadNextCatRecord - Read the next record of a category
  929.  
  930.    SYNOPSIS
  931.         Length = DLP_ReadNextCatRecord(Socket,DBHandle,Cat,Buffer,ID,Index,Size,Attr)
  932.           D0.l                          A0.l    D0.l  D1.b  A1.l A2.l A3.l D2.l D3.l
  933.  
  934.         LONG DLP_ReadNextCatRecord(APTR,ULONG,UBYTE,APTR,ULONG *,UWORD *,UWORD *,UBYTE *);
  935.  
  936.    FUNCTION
  937.         Read the next record of a given category.
  938.  
  939.    INPUTS
  940.         Socket        -- (APTR) Socket
  941.         DBHandle      -- (LONG) Database handle
  942.         Cat           -- (UBYTE) Category ID
  943.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  944.                 a sufficient size of 65535 byte.
  945.         ID            -- (ULONG *) If a pointer is provided, the record ID
  946.                 is copied there. You may provide NULL.
  947.         Index         -- (UWORD *) If a pointer is provided, the record index
  948.                 is copied there. You may provide NULL.
  949.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  950.                 with the size of this resource. You may provide NULL.
  951.                 Assembler users watch out: this is a pointer in a data register!
  952.         Attr          -- (UBYTE *) If a pointer is provided, the UBYTE is filled
  953.                 with the record attributes. You may provide NULL.
  954.                 Assembler users watch out: this is a pointer in a data register!
  955.  
  956.    RESULT
  957.         Length        -- (LONG) Record bytes that were really read, or -1 if
  958.                 an error occured.
  959.  
  960.    NOTE
  961.         This function requires PalmOS 2.0 or higher. There is workaround
  962.         for OS 1.0, but since it is quite outdated, I see no reason to
  963.         implement it. If you require it, please get in contact with me.
  964.  
  965.    BUGS
  966.  
  967.    SEE ALSO
  968.  
  969.  
  970. palmlink.library/DLP_ReadNextModifiedCatRecord
  971.  
  972.    NAME
  973.         DLP_ReadNextModifiedCatRecord - Read the next modified record of a category
  974.  
  975.    SYNOPSIS
  976.         Length = DLP_ReadNextModifiedCatRecord(Socket,DBHandle,Cat,Buffer,ID,Index,Size,Attr)
  977.           D0.l                                  A0.l    D0.l  D1.b  A1.l A2.l A3.l D2.l D3.l
  978.  
  979.         LONG DLP_ReadNextModifiedCatRecord(APTR,ULONG,UBYTE,APTR,ULONG *,UWORD *,UWORD *,UBYTE *);
  980.  
  981.    FUNCTION
  982.         Read the next modified record of a given category.
  983.  
  984.    INPUTS
  985.         Socket        -- (APTR) Socket
  986.         DBHandle      -- (LONG) Database handle
  987.         Cat           -- (UBYTE) Category ID
  988.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  989.                 a sufficient size of 65535 byte.
  990.         ID            -- (ULONG *) If a pointer is provided, the record ID
  991.                 is copied there. You may provide NULL.
  992.         Index         -- (UWORD *) If a pointer is provided, the record index
  993.                 is copied there. You may provide NULL.
  994.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  995.                 with the size of this resource. You may provide NULL.
  996.                 Assembler users watch out: this is a pointer in a data register!
  997.         Attr          -- (UBYTE *) If a pointer is provided, the UBYTE is filled
  998.                 with the record attributes. You may provide NULL.
  999.                 Assembler users watch out: this is a pointer in a data register!
  1000.  
  1001.    RESULT
  1002.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1003.                 an error occured.
  1004.  
  1005.    NOTE
  1006.         This function requires PalmOS 2.0 or higher. There is workaround
  1007.         for OS 1.0, but since it is quite outdated, I see no reason to
  1008.         implement it. If you require it, please get in contact with me.
  1009.  
  1010.         No, there is no longer function name in this library. ;-)
  1011.  
  1012.    BUGS
  1013.  
  1014.    SEE ALSO
  1015.  
  1016.  
  1017. palmlink.library/DLP_ReadRecordByID
  1018.  
  1019.    NAME
  1020.         DLP_ReadRecordByID - Read a record by ID
  1021.  
  1022.    SYNOPSIS
  1023.         Length = DLP_ReadRecordByID(Socket,DBHandle,ID,Buffer,Index,Size,Attr,Cat);
  1024.          D0.l                        A0.l    D0.l  D1.l A1.l  A2.l  A3.l D2.l D3.l
  1025.  
  1026.         LONG DLP_ReadRecordByID(APTR,LONG,ULONG,APTR,UWORD *,UWORD *,UBYTE *,UBYTE *);
  1027.  
  1028.    FUNCTION
  1029.         Read a record from the database, by its ID.
  1030.  
  1031.    INPUTS
  1032.         Socket        -- (APTR) Socket
  1033.         DBHandle      -- (LONG) Database handle
  1034.         ID            -- (ULONG) Record ID
  1035.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  1036.                 a sufficient size of 65535 byte.
  1037.         Index         -- (UWORD *) If a pointer is provided, the record index
  1038.                 is copied there. You may provide NULL.
  1039.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1040.                 with the size of this record. You may provide NULL.
  1041.         Attr          -- (UBYTE *) If a pointer is provided, the record attribute
  1042.                 is copied there. You may provide NULL.
  1043.                 Assembler users watch out: this is a pointer in a data register!
  1044.         Cat           -- (UBYTE *) If a pointer is provided, the record category
  1045.                 is copied there. You may provide NULL.
  1046.                 Assembler users watch out: this is a pointer in a data register!
  1047.  
  1048.  
  1049.    RESULT
  1050.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1051.                 an error occured.
  1052.  
  1053.    NOTE
  1054.  
  1055.    BUGS
  1056.  
  1057.    SEE ALSO
  1058.  
  1059.  
  1060. palmlink.library/DLP_ReadRecordByIndex
  1061.  
  1062.    NAME
  1063.         DLP_ReadRecordByIndex - Read a record by Index
  1064.  
  1065.    SYNOPSIS
  1066.         Length = DLP_ReadRecordByIndex(Socket,DBHandle,Index,Buffer,ID,Size,Attr,Cat);
  1067.          D0.l                           A0.l    D0.l    D1.l A1.l  A2.l A3.l D2.l D3.l
  1068.  
  1069.         LONG DLP_ReadRecordByIndex(APTR,LONG,UWORD,APTR,ULONG *,UWORD *,UBYTE *,UBYTE *);
  1070.  
  1071.    FUNCTION
  1072.         Read a record from the database, by its index.
  1073.  
  1074.    INPUTS
  1075.         Socket        -- (APTR) Socket
  1076.         DBHandle      -- (LONG) Database handle
  1077.         Index         -- (UWORD) Index of the record
  1078.         Buffer        -- (APTR) Buffer for the record. The buffer must have
  1079.                 a sufficient size of 65535 byte.
  1080.         ID            -- (ULONG *) If a pointer is provided, the record ID
  1081.                 is copied there. You may provide NULL.
  1082.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1083.                 with the size of this record. You may provide NULL.
  1084.         Attr          -- (UBYTE *) If a pointer is provided, the record attribute
  1085.                 is copied there. You may provide NULL.
  1086.                 Assembler users watch out: this is a pointer in a data register!
  1087.         Cat           -- (UBYTE *) If a pointer is provided, the record category
  1088.                 is copied there. You may provide NULL.
  1089.                 Assembler users watch out: this is a pointer in a data register!
  1090.  
  1091.  
  1092.    RESULT
  1093.         Length        -- (LONG) Record bytes that were really read, or -1 if
  1094.                 an error occured.
  1095.  
  1096.    NOTE
  1097.  
  1098.    BUGS
  1099.  
  1100.    SEE ALSO
  1101.  
  1102.  
  1103. palmlink.library/DLP_ReadResourceByIndex
  1104.  
  1105.    NAME
  1106.         DLP_ReadResourceByIndex - Read a resource by index
  1107.  
  1108.    SYNOPSIS
  1109.         Length = DLP_ReadResourceByIndex(Socket,DBHandle,Index,Buffer,Type,ID,Size)
  1110.           D0.l                            A0.l    D0.l    D1.w  A1.l  A2.l A3.l D2.l
  1111.  
  1112.         LONG DLP_ReadResourceByIndex(APTR,LONG,UWORD,APTR,ULONG *,UWORD *,UWORD *);
  1113.  
  1114.    FUNCTION
  1115.         Read a resource from the database, by its index.
  1116.  
  1117.    INPUTS
  1118.         Socket        -- (APTR) Socket
  1119.         DBHandle      -- (LONG) Database handle
  1120.         Index         -- (UWORD) Index of the resource
  1121.         Buffer        -- (APTR) Buffer for the resource. The buffer must have
  1122.                 a sufficient size of 65535 byte.
  1123.         Type          -- (ULONG *) If a pointer is provided, the resource type
  1124.                 is copied there. You may provide NULL.
  1125.         ID            -- (UWORD *) If a pointer is provided, the resource ID
  1126.                 is copied there. You may provide NULL.
  1127.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1128.                 with the size of this resource. You may provide NULL.
  1129.                 Assembler users watch out: this is a pointer in a data register!
  1130.  
  1131.    RESULT
  1132.         Length        -- (LONG) Resource bytes that were really read, or -1 if
  1133.                 an error occured.
  1134.  
  1135.    NOTE
  1136.  
  1137.    BUGS
  1138.  
  1139.    SEE ALSO
  1140.  
  1141.  
  1142. palmlink.library/DLP_ReadResourceByType
  1143.  
  1144.    NAME
  1145.         DLP_ReadResourceByType - Read a resource by its type
  1146.  
  1147.    SYNOPSIS
  1148.         Length = DLP_ReadResourceByType(Socket,DBHandle,Type,ID,Buffer,Index,Size)
  1149.           D0.l                           A0.l   D0.l    D1.l D2.w A1.l  A2.l A3.l
  1150.  
  1151.         LONG DLP_ReadResourceByType(APTR,LONG,ULONG,UWORD,APTR,UWORD *,UWORD *);
  1152.  
  1153.    FUNCTION
  1154.         Read a resource from the database, by its type and ID.
  1155.  
  1156.    INPUTS
  1157.         Socket        -- (APTR) Socket
  1158.         DBHandle      -- (LONG) Database handle
  1159.         Type          -- (ULONG) Resource type
  1160.         ID            -- (UWORD) Resource ID
  1161.         Buffer        -- (APTR) Buffer for the resource. The buffer must have
  1162.                 a sufficient size of 65535 byte.
  1163.         Index         -- (UWORD *) If a pointer is provided, the UWORD is filled
  1164.                 with the index of this resource. You may provide NULL.
  1165.         Size          -- (UWORD *) If a pointer is provided, the UWORD is filled
  1166.                 with the size of this resource. You may provide NULL.
  1167.  
  1168.    RESULT
  1169.         Length        -- (LONG) Resource bytes that were really read, or -1 if
  1170.                 an error occured.
  1171.  
  1172.    NOTE
  1173.  
  1174.    BUGS
  1175.  
  1176.    SEE ALSO
  1177.  
  1178.  
  1179. palmlink.library/DLP_ReadSortBlock
  1180.  
  1181.    NAME
  1182.         DLP_ReadSortBlock - Read a sort block
  1183.  
  1184.    SYNOPSIS
  1185.         Length = DLP_ReadSortBlock(Socket,DBHandle,Offset,Buffer,Length)
  1186.           D0.l                      A0.l    D0.l    D1.w   A1.l   D2.w
  1187.  
  1188.         LONG DLP_ReadSortBlock(APTR,LONG,UWORD,APTR,UWORD);
  1189.  
  1190.    FUNCTION
  1191.         Read the sort block of the database.
  1192.  
  1193.    INPUTS
  1194.         Socket        -- (APTR) Socket
  1195.         DBHandle      -- (LONG) Database handle
  1196.         Offset        -- (UWORD) Offset into the sort block
  1197.         Buffer        -- (APTR) Buffer for the sort block
  1198.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1199.                 size is 65535 byte.
  1200.  
  1201.    RESULT
  1202.         Length        -- (LONG) SortBlock bytes that were really read, or -1 if
  1203.                 an error occured.
  1204.  
  1205.    NOTE
  1206.  
  1207.    BUGS
  1208.  
  1209.    SEE ALSO
  1210.  
  1211.  
  1212. palmlink.library/DLP_ResetDBIndex
  1213.  
  1214.    NAME
  1215.         DLP_ResetDBIndex - Restart from the first DB entry
  1216.  
  1217.    SYNOPSIS
  1218.         Success = DLP_ResetDBIndex(Socket,DBHandle)
  1219.           D0.l                      A0.l    D0.l
  1220.  
  1221.         int DLP_ResetDBIndex(APTR,LONG);
  1222.  
  1223.    FUNCTION
  1224.         Resets the internal DB index counter to the start of the
  1225.         database.
  1226.  
  1227.    INPUTS
  1228.         Socket        -- (APTR) Socket
  1229.         DBHandle      -- (LONG) Database handle
  1230.  
  1231.    RESULT
  1232.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1233.  
  1234.    NOTE
  1235.  
  1236.    BUGS
  1237.  
  1238.    SEE ALSO
  1239.  
  1240.  
  1241. palmlink.library/DLP_ResetLastSyncPC
  1242.  
  1243.    NAME
  1244.         DLP_ResetLastSyncPC - Clears the LastSyncPC
  1245.  
  1246.    SYNOPSIS
  1247.         Success = DLP_ResetLastSyncPC(Socket)
  1248.           D0.l                         A0.l
  1249.  
  1250.         int DLP_ResetLastSyncPC(APTR);
  1251.  
  1252.    FUNCTION
  1253.         Reset the LastSyncPC field in the UserInfo.
  1254.  
  1255.    INPUTS
  1256.         Socket        -- (APTR) Socket
  1257.  
  1258.    RESULT
  1259.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1260.  
  1261.    NOTE
  1262.  
  1263.    BUGS
  1264.  
  1265.    SEE ALSO
  1266.  
  1267.  
  1268. palmlink.library/DLP_ResetSyncFlags
  1269.  
  1270.    NAME
  1271.         DLP_ResetSyncFlags - Reset all sync flags of the database
  1272.  
  1273.    SYNOPSIS
  1274.         Success = DLP_ResetSyncFlags(Socket,DBHandle)
  1275.           D0.l                        A0.l    D0.l
  1276.  
  1277.         int DLP_ResetSyncFlags(APTR,LONG);
  1278.  
  1279.    FUNCTION
  1280.         All sync flags of the database are reset.
  1281.  
  1282.    INPUTS
  1283.         Socket        -- (APTR) Socket
  1284.         DBHandle      -- (LONG) Handle of the database.
  1285.  
  1286.    RESULT
  1287.         Success       -- (int) TRUE: this call succeeded. FALSE: an
  1288.                 error occured (see PL_LastError()).
  1289.  
  1290.    NOTE
  1291.  
  1292.    BUGS
  1293.  
  1294.    SEE ALSO
  1295.  
  1296.  
  1297. palmlink.library/DLP_ResetSystem
  1298.  
  1299.    NAME
  1300.         DLP_ResetSystem - Reset the Palm Pilot
  1301.  
  1302.    SYNOPSIS
  1303.         Success = DLP_ResetSystem(Socket)
  1304.           D0.l                     A0.l
  1305.  
  1306.         int DLP_ResetSystem(APTR);
  1307.  
  1308.    FUNCTION
  1309.         Reset the Palm Pilot when the connection is closed.
  1310.  
  1311.    INPUTS
  1312.         Socket        -- (APTR) Socket
  1313.  
  1314.    RESULT
  1315.         Success       -- (int) FALSE: an error occured, see PL_LastError()
  1316.  
  1317.    NOTE
  1318.  
  1319.    BUGS
  1320.  
  1321.    SEE ALSO
  1322.  
  1323.  
  1324. palmlink.library/DLP_SetNetSyncInfo
  1325.  
  1326.    NAME
  1327.         DLP_SetNetSyncInfo - Set information about net sync
  1328.  
  1329.    SYNOPSIS
  1330.         Success = DLP_SetNetSyncInfo(Socket,NetSync)
  1331.           D0.l                        A0.l   A1.l
  1332.  
  1333.         int DLP_SetNetSyncInfo(APTR,struct DLP_NetSyncInfo *);
  1334.  
  1335.    FUNCTION
  1336.         Set information about net sync from the DLP_NetSyncInfo structure.
  1337.  
  1338.    INPUTS
  1339.         Socket        -- (APTR) Socket
  1340.         NetSync       -- (struct DLP_NetSyncInfo *) NetSync to be set
  1341.  
  1342.    RESULT
  1343.         Success       -- (int) TRUE: NetSyncInfo has been set.
  1344.  
  1345.    NOTE
  1346.         This function requires PalmOS 2.0 or higher. There is workaround
  1347.         for OS 1.0, but since it is quite outdated, I see no reason to
  1348.         implement it. If you require it, please get in contact with me.
  1349.  
  1350.    BUGS
  1351.  
  1352.    SEE ALSO
  1353.         DLP_GetNetSyncInfo()
  1354.  
  1355.  
  1356. palmlink.library/DLP_SetSysTime
  1357.  
  1358.    NAME
  1359.         DLP_SetSysTime - Set the Pilot system time
  1360.  
  1361.    SYNOPSIS
  1362.         Success = DLP_SetSysTime(Socket,Time)
  1363.           D0.l                    A0.l  A1.l
  1364.  
  1365.         int DLP_SetSysTime(APTR,struct DLP_SysTime *);
  1366.  
  1367.    FUNCTION
  1368.         The internal clock of the Palm Pilot is set according to the
  1369.         passed DLP_SysTime structure.
  1370.  
  1371.    INPUTS
  1372.         Socket        -- (APTR) Socket
  1373.         Time          -- (struct DLP_SysTime *) Time to set
  1374.  
  1375.    RESULT
  1376.         Success       -- (int) TRUE: Time has been set.
  1377.  
  1378.    NOTE
  1379.  
  1380.    BUGS
  1381.  
  1382.    SEE ALSO
  1383.         DLP_GetSysTime()
  1384.  
  1385.  
  1386. palmlink.library/DLP_SetUserInfo
  1387.  
  1388.    NAME
  1389.         DLP_SetUserInfo - Set information about the Pilot user
  1390.  
  1391.    SYNOPSIS
  1392.         Success = DLP_SetUserInfo(Socket,User)
  1393.           D0.l                     A0.l  A1.l
  1394.  
  1395.         int DLP_SetUserInfo(APTR,struct DLP_UserInfo *);
  1396.  
  1397.    FUNCTION
  1398.         Set information about the Pilot user (most probably you ;-)
  1399.         from the DLP_UserInfo structure.
  1400.  
  1401.    INPUTS
  1402.         Socket        -- (APTR) Socket
  1403.         User          -- (struct DLP_UserInfo *) UserInfo to be set
  1404.  
  1405.    RESULT
  1406.         Success       -- (int) TRUE: UserInfo has been set.
  1407.  
  1408.    NOTE
  1409.  
  1410.    BUGS
  1411.  
  1412.    SEE ALSO
  1413.         DLP_GetUserInfo()
  1414.  
  1415.  
  1416. palmlink.library/DLP_WriteAppBlock
  1417.  
  1418.    NAME
  1419.         DLP_WriteAppBlock - Write an application block
  1420.  
  1421.    SYNOPSIS
  1422.         Success = DLP_WriteAppBlock(Socket,DBHandle,Buffer,Length)
  1423.           D0.l                      A0.l    D0.l    A1.l   D1.w
  1424.  
  1425.         int DLP_WriteAppBlock(APTR,LONG,APTR,UWORD);
  1426.  
  1427.    FUNCTION
  1428.         Write the application block into the database.
  1429.  
  1430.    INPUTS
  1431.         Socket        -- (APTR) Socket
  1432.         DBHandle      -- (LONG) Database handle
  1433.         Buffer        -- (APTR) Buffer for the application block
  1434.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1435.                 size is 65535 byte.
  1436.  
  1437.    RESULT
  1438.         Success       -- (int) TRUE: AppBlock has been written successfully
  1439.  
  1440.    NOTE
  1441.  
  1442.    BUGS
  1443.  
  1444.    SEE ALSO
  1445.  
  1446.  
  1447. palmlink.library/DLP_WriteAppPreference
  1448.  
  1449.    NAME
  1450.         DLP_WriteAppPreference - Write the preference of an application
  1451.  
  1452.    SYNOPSIS
  1453.         Success = DLP_WriteAppPreference(Socket,Creator,ID,Saved,Version,Buffer,Length)
  1454.           D0.l                            A0.l   D0.l  D1.w D2.w  D3.w    A1.l   D4.w
  1455.  
  1456.         int DLP_WriteAppPreference(APTR,ULONG,UWORD,BOOL,UWORD,APTR,UWORD);
  1457.  
  1458.    FUNCTION
  1459.         Write the preferences of an application. You can choose between the
  1460.         saved and the temporary version of the preference.
  1461.  
  1462.    INPUTS
  1463.         Socket        -- (APTR) Socket
  1464.         Creator       -- (ULONG) Creator of the application
  1465.         ID            -- (UWORD) ID number of the preference (lets an
  1466.                 application have multiple preferences)
  1467.         Saved         -- (BOOL) TRUE: save the preference, FALSE: use
  1468.                 the preference as current settings.
  1469.         Version       -- (UWORD) Preference version
  1470.         Buffer        -- (APTR) Buffer where the preferences are stored
  1471.         Length        -- (UWORD) Length of the preference block
  1472.  
  1473.    RESULT
  1474.         Success       -- (int) TRUE: Preference has been set successfully.
  1475.  
  1476.    NOTE
  1477.         This function requires PalmOS 2.0 or higher. There is workaround
  1478.         for OS 1.0, but since it is quite outdated, I see no reason to
  1479.         implement it. If you require it, please get in contact with me.
  1480.  
  1481.    BUGS
  1482.  
  1483.    SEE ALSO
  1484.  
  1485.  
  1486. palmlink.library/DLP_WriteRecord
  1487.  
  1488.    NAME
  1489.         DLP_WriteRecord - Write a record to the database
  1490.  
  1491.    SYNOPSIS
  1492.         Success = DLP_WriteRecord(Socket,DBHandle,Flags,ID,CatID,Buffer,Length,NewID)
  1493.           D0.l                     A0.l   D0.l    D1.b D2.l D3.b  A1.l   D4.w   A2.l
  1494.  
  1495.         int DLP_WriteRecord(APTR,LONG,UBYTE,ULONG,UBYTE,APTR,UWORD,ULONG *);
  1496.  
  1497.    FUNCTION
  1498.         Write a record to the database.
  1499.  
  1500.    INPUTS
  1501.         Socket        -- (APTR) Socket
  1502.         DBHandle      -- (LONG) Database handle
  1503.         Flags         -- (UBYTE) Write flags (see includes)
  1504.         ID            -- (ULONG) Record ID
  1505.         CatID         -- (UBYTE) Record Category ID
  1506.         Buffer        -- (APTR) Data to write to the record
  1507.         Length        -- (UWORD) Length of the buffer (as you see, a record
  1508.                 can only contain 65535 byte).
  1509.         NewID         -- (ULONG *) The record ID that has been used can be
  1510.                 returned in this buffer. Provide NULL if you don't need it.
  1511.  
  1512.    RESULT
  1513.         Success       -- (int) TRUE: Record has bee written.
  1514.  
  1515.    NOTE
  1516.  
  1517.    BUGS
  1518.  
  1519.    SEE ALSO
  1520.  
  1521.  
  1522. palmlink.library/DLP_WriteResource
  1523.  
  1524.    NAME
  1525.         DLP_WriteResource - Write a resource to the database
  1526.  
  1527.    SYNOPSIS
  1528.         Success = DLP_WriteResource(Socket,DBHandle,Type,ID,Buffer,Length)
  1529.           D0.l                       A0.l   D0.l    D1.l D2.w A1.l  D3.w
  1530.  
  1531.         int DLP_WriteResource(APTR,LONG,ULONG,UWORD,APTR,UWORD);
  1532.  
  1533.    FUNCTION
  1534.         Write a resource to the database.
  1535.  
  1536.    INPUTS
  1537.         Socket        -- (APTR) Socket
  1538.         DBHandle      -- (LONG) Database handle
  1539.         Type          -- (ULONG) Resource type
  1540.         ID            -- (UWORD) Resource ID
  1541.         Buffer        -- (APTR) Data to write to the resource
  1542.         Length        -- (UWORD) Length of the buffer (as you see, a resource
  1543.                 can only contain 65535 byte).
  1544.  
  1545.    RESULT
  1546.         Success       -- (int) TRUE: Resource has been written.
  1547.  
  1548.    NOTE
  1549.  
  1550.    BUGS
  1551.  
  1552.    SEE ALSO
  1553.  
  1554.  
  1555. palmlink.library/DLP_WriteSortBlock
  1556.  
  1557.    NAME
  1558.         DLP_WriteSortBlock - Write a sort block
  1559.  
  1560.    SYNOPSIS
  1561.         Success = DLP_WriteSortBlock(Socket,DBHandle,Buffer,Length)
  1562.           D0.l                       A0.l    D0.l    A1.l   D1.w
  1563.  
  1564.         int DLP_WriteSortBlock(APTR,LONG,APTR,UWORD);
  1565.  
  1566.    FUNCTION
  1567.         Write the sort block into the database.
  1568.  
  1569.    INPUTS
  1570.         Socket        -- (APTR) Socket
  1571.         DBHandle      -- (LONG) Database handle
  1572.         Buffer        -- (APTR) Buffer for the sort block
  1573.         Length        -- (UWORD) Length of the buffer. As you see, the maximum
  1574.                 size is 65535 byte.
  1575.  
  1576.    RESULT
  1577.         Success       -- (int) TRUE: SortBlock has been written successfully
  1578.  
  1579.    NOTE
  1580.  
  1581.    BUGS
  1582.  
  1583.    SEE ALSO
  1584.  
  1585.  
  1586. palmlink.library/PL_Accept
  1587.  
  1588.    NAME
  1589.         PL_Accept - accept a connection
  1590.  
  1591.    SYNOPSIS
  1592.         Success = PL_Accept(Socket, Timeout)
  1593.         D0.l                 A0.l    D0.l
  1594.  
  1595.         int PL_Accept(APTR, ULONG);
  1596.  
  1597.    FUNCTION
  1598.         Wait for a connection request from Palm Pilot, and accept it. If
  1599.         there was no connection until Timeout, a timeout error will be
  1600.         returned.
  1601.  
  1602.         Usually, the connection is started by pressing the HotSync button
  1603.         on the cradle.
  1604.  
  1605.         You can read the error code using PL_LastError().
  1606.  
  1607.    INPUTS
  1608.         Socket        -- (APTR) Socket
  1609.         Timeout       -- (ULONG) Timeout (seconds) until this function
  1610.                          returns.
  1611.  
  1612.    RESULT
  1613.         Success       -- (int) TRUE if a connection request has been
  1614.                          accepted.
  1615.  
  1616.    NOTE
  1617.  
  1618.    BUGS
  1619.         The timeout may be some seconds longer than provided.
  1620.  
  1621.    SEE ALSO
  1622.  
  1623. palmlink.library/PL_AddRexxHandle
  1624.  
  1625.    NAME
  1626.         PL_AddRexxHandle - Add an ARexx created handle
  1627.  
  1628.    SYNOPSIS
  1629.         PL_AddRexxHandle(Socket, Name)
  1630.                          A0.l    A1.l
  1631.  
  1632.         void PL_AddRexxHandle(APTR, STRPTR);
  1633.  
  1634.    FUNCTION
  1635.         After a socket has been created by an ARexx function, its handle
  1636.         is maintained by the palmlink.library.
  1637.  
  1638.         This function adds the new handle to the internal list.
  1639.  
  1640.    INPUTS
  1641.         Socket        -- (APTR) Socket
  1642.         Name          -- (STRPTR) Name of the handle
  1643.  
  1644.    RESULT
  1645.  
  1646.    NOTE
  1647.         This is a PRIVATE function. Do NOT use it. You have been warned! ;-)
  1648.  
  1649.    BUGS
  1650.         If the name does already exist, it will exist twice after this call.
  1651.  
  1652.    SEE ALSO
  1653.         PL_DeleteRexxHandle(), PL_FindRexxHandle()
  1654.  
  1655. palmlink.library/PL_CloseSocket
  1656.  
  1657.    NAME
  1658.         PL_CloseSocket - close a socket to a Palm Pilot
  1659.  
  1660.    SYNOPSIS
  1661.         PL_CloseSocket(Socket)
  1662.                         A0.l
  1663.  
  1664.         void PL_CloseSocket(APTR);
  1665.  
  1666.    FUNCTION
  1667.         Close a socket to a Palm Pilot. Make sure to close all data bases
  1668.         before. PalmLink won't do this for you.
  1669.  
  1670.    INPUTS
  1671.         Socket        -- (APTR) Socket to be closed. NULL will do nothing.
  1672.  
  1673.    RESULT
  1674.  
  1675.    NOTE
  1676.  
  1677.    BUGS
  1678.  
  1679.    SEE ALSO
  1680.         PL_OpenSocket()
  1681.  
  1682.  
  1683. palmlink.library/PL_CMPAbort
  1684.  
  1685.    NAME
  1686.         PL_CMPAbort - Abort a connection
  1687.  
  1688.    SYNOPSIS
  1689.         Success = PL_CMPAbort(Socket,Reason)
  1690.         D0.l                   A0.l   D0.b
  1691.  
  1692.         int PL_CMPAbort(APTR,UBYTE);
  1693.  
  1694.    FUNCTION
  1695.         Abort a connection, using CMP (Connection Management Protocol).
  1696.         The appropriate reason is transmitted.
  1697.  
  1698.         If this function fails (i.e. it returns false), you can read
  1699.         the error code using PL_LastError().
  1700.  
  1701.         This is a low level call, and is used by the palmlink.library
  1702.         itself. Usually, you do not need to use this function.
  1703.  
  1704.    INPUTS
  1705.         Socket        -- (APTR) Socket
  1706.         Reason        -- (UBYTE) Reason for the abortion
  1707.  
  1708.    RESULT
  1709.         Success       -- (int) TRUE: The abort request has been sent
  1710.                 successfully. FALSE: An error occured.
  1711.  
  1712.    NOTE
  1713.  
  1714.    BUGS
  1715.  
  1716.    SEE ALSO
  1717.         PL_CMPRead(), PL_CMPInit(), PL_CMPWakeUp()
  1718.  
  1719.  
  1720. palmlink.library/PL_CMPInit
  1721.  
  1722.    NAME
  1723.         PL_CMPInit - Initialize a connection
  1724.  
  1725.    SYNOPSIS
  1726.         Success = PL_CMPInit(Socket,Rate)
  1727.         D0.l                  A0.l  D0.l
  1728.  
  1729.         int PL_CMPInit(APTR,ULONG);
  1730.  
  1731.    FUNCTION
  1732.         After being waked up, the connection is initialized using
  1733.         CMP (Connection Management Protocol). The desired baud rate
  1734.         is passed. It must be below the maximum baud rate that has
  1735.         been transmitted by the WakeUp packet. If the Palm Pilot does
  1736.         not support the desired rate, this function will fail.
  1737.  
  1738.         If this function fails (i.e. it returns false), you can read
  1739.         the error code using PL_LastError().
  1740.  
  1741.         This is a low level call, and is used by the palmlink.library
  1742.         itself. Usually, you do not need to use this function.
  1743.  
  1744.    INPUTS
  1745.         Socket        -- (APTR) Socket
  1746.         Rate          -- (ULONG) Desired baud rate, in bps
  1747.  
  1748.    RESULT
  1749.         Success       -- (int) TRUE: The initialization has been sent
  1750.                 successfully. FALSE: An error occured.
  1751.  
  1752.    NOTE
  1753.         It is guaranteed that the Palm Pilot supports 9600 bps. The
  1754.         maximum baud rate (at least of the Palm III) is 57600 bps.
  1755.  
  1756.         This call will not set the serial interface to the new baud
  1757.         rate!
  1758.  
  1759.    BUGS
  1760.  
  1761.    SEE ALSO
  1762.         PL_CMPRead(), PL_CMPAbort(), PL_CMPWakeUp()
  1763.  
  1764.  
  1765. palmlink.library/PL_CMPRead
  1766.  
  1767.    NAME
  1768.         PL_CMPRead - read a packet using CMP
  1769.  
  1770.    SYNOPSIS
  1771.         Success = PL_CMPRead(Socket,CMP)
  1772.         D0.l                  A0.l  A1.l
  1773.  
  1774.         int PL_CMPRead(APTR,struct PL_CMP *);
  1775.  
  1776.    FUNCTION
  1777.         Read a CMP packet from the Palm Pilot. A space for the CMP
  1778.         structure must be provided.
  1779.  
  1780.         If this function fails (i.e. it returns false), you can read
  1781.         the error code using PL_LastError().
  1782.  
  1783.         This is a low level call, and is used by the palmlink.library
  1784.         itself. Usually, you do not need to use this function.
  1785.  
  1786.    INPUTS
  1787.         Socket        -- (APTR) Socket
  1788.         CMP           -- (struct PL_CMP *) CMP structure to be filled
  1789.  
  1790.    RESULT
  1791.         Success       -- (int) TRUE: The CMP structure has been read
  1792.                 successfully. FALSE: An error occured.
  1793.  
  1794.    NOTE
  1795.  
  1796.    BUGS
  1797.  
  1798.    SEE ALSO
  1799.         PL_CMPInit(), PL_CMPAbort(), PL_CMPWakeUp()
  1800.  
  1801.  
  1802. palmlink.library/PL_CMPWakeUp
  1803.  
  1804.    NAME
  1805.         PL_CMPWakeUp - Wake up the remote side
  1806.  
  1807.    SYNOPSIS
  1808.         Success = PL_CMPWakeUp(Socket,MaxRate)
  1809.         D0.l                    A0.l   D0.l
  1810.  
  1811.         int PL_CMPWakeUp(APTR,ULONG);
  1812.  
  1813.    FUNCTION
  1814.         Wake up the remote side of a connection, using CMP (Connection
  1815.         Management Protocol). We pass the maximum baud rate we support.
  1816.         The Palm Pilot will answer with a CMP Init packet, giving the
  1817.         baud rate it will use for further communication.
  1818.  
  1819.         If this function fails (i.e. it returns false), you can read
  1820.         the error code using PL_LastError().
  1821.  
  1822.         This is a low level call, and is used by the palmlink.library
  1823.         itself. Usually, you do not need to use this function.
  1824.  
  1825.    INPUTS
  1826.         Socket        -- (APTR) Socket
  1827.         MaxRate       -- (ULONG) Maximum baud rate, in bps
  1828.  
  1829.    RESULT
  1830.         Success       -- (int) TRUE: The wake up has been sent
  1831.                 successfully. FALSE: An error occured.
  1832.  
  1833.    NOTE
  1834.         This call will not set the serial interface to the new baud
  1835.         rate!
  1836.  
  1837.    BUGS
  1838.  
  1839.    SEE ALSO
  1840.         PL_CMPRead(), PL_CMPAbort(), PL_CMPInit()
  1841.  
  1842.  
  1843. palmlink.library/PL_Connect
  1844.  
  1845.    NAME
  1846.         PL_Connect - initiate a connection to the Palm Pilot
  1847.  
  1848.    SYNOPSIS
  1849.         Success = PL_Connect(Socket)
  1850.         D0.l                  A0.l
  1851.  
  1852.         int PL_Connect(APTR);
  1853.  
  1854.    FUNCTION
  1855.         Initiate a connection to the Palm Pilot. If the connection could
  1856.         not be established, or was refused, an error occures.
  1857.  
  1858.         You can read the error code using PL_LastError().
  1859.  
  1860.    INPUTS
  1861.         Socket        -- (APTR) Socket
  1862.  
  1863.    RESULT
  1864.         Success       -- (int) TRUE if a connection has been established.
  1865.  
  1866.    NOTE
  1867.  
  1868.    BUGS
  1869.         This function does not seem to work since the Palm Pilot does not
  1870.         accept wakeup requests. I will have a look at this later. Anyhow
  1871.         you should use PL_Accept() and let the user decide when he wants
  1872.         to sync.
  1873.  
  1874.    SEE ALSO
  1875.  
  1876. palmlink.library/PL_DeleteRexxHandle
  1877.  
  1878.    NAME
  1879.         PL_DeleteRexxHandle - Deletes an ARexx created handle
  1880.  
  1881.    SYNOPSIS
  1882.         PL_DeleteRexxHandle(Name)
  1883.                             A0.l
  1884.  
  1885.         void PL_DeleteRexxHandle(STRPTR);
  1886.  
  1887.    FUNCTION
  1888.         After a socket has been created by an ARexx function, its handle
  1889.         is maintained by the palmlink.library.
  1890.  
  1891.         This function deletes an existing handle from the internal list.
  1892.  
  1893.         If the handle did not exist, nothing will happen.
  1894.  
  1895.    INPUTS
  1896.         Name          -- (STRPTR) Name of the handle
  1897.  
  1898.    RESULT
  1899.  
  1900.    NOTE
  1901.         This is a PRIVATE function. Do NOT use it. You have been warned! ;-)
  1902.  
  1903.    BUGS
  1904.  
  1905.    SEE ALSO
  1906.         PL_AddRexxHandle(), PL_FindRexxHandle()
  1907.  
  1908. palmlink.library/PL_DLPInit
  1909.  
  1910.    NAME
  1911.         PL_DLPInit - Initialize a DLP data transfer
  1912.  
  1913.    SYNOPSIS
  1914.         PL_DLPInit(Socket)
  1915.                     A0.l
  1916.  
  1917.         void PL_DLPInit(APTR);
  1918.  
  1919.    FUNCTION
  1920.         The internal DLP buffer is initialized and prepared for a
  1921.         new DLP transmission.
  1922.  
  1923.         This is a low level call, and is used by the palmlink.library
  1924.         itself. Usually, you do not need to use this function.
  1925.  
  1926.    INPUTS
  1927.         Socket        -- (APTR) Socket
  1928.  
  1929.    RESULT
  1930.  
  1931.    NOTE
  1932.         The DLP buffer has sufficient space for a whole DLP packet
  1933.         of 64KByte.
  1934.  
  1935.    BUGS
  1936.         There is no arbitration yet. Only the task that initiated the
  1937.         socket is allowed to use this function.
  1938.  
  1939.         Nested calls are not supported.
  1940.  
  1941.         You must not patch this function.
  1942.  
  1943.    SEE ALSO
  1944.         PL_DLPWriteByte(), PL_DLPWriteWord(), PL_DLPWriteLong(),
  1945.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  1946.  
  1947.  
  1948. palmlink.library/PL_DLPRead
  1949.  
  1950.    NAME
  1951.         PL_DLPRead - Read the DLP reply
  1952.  
  1953.    SYNOPSIS
  1954.         Length = PL_DLPRead(Socket,Buffer,Length)
  1955.          D0.l                A0.l   A1.l   D0.l
  1956.  
  1957.         LONG PL_DLPRead(APTR,APTR,LONG);
  1958.  
  1959.    FUNCTION
  1960.         After a command has been sent using, PL_DLPSend(), you can use
  1961.         this call to sequential read the reply. The current part is
  1962.         copied into the buffer.
  1963.  
  1964.         This is a low level call, and is used by the palmlink.library
  1965.         itself. Usually, you do not need to use this function.
  1966.  
  1967.    INPUTS
  1968.         Socket        -- (APTR) Socket
  1969.         Buffer        -- (APTR) Buffer that will contain the part of
  1970.                 the reply packet.
  1971.         Length        -- (LONG) Length of the buffer
  1972.  
  1973.    RESULT
  1974.         Length        -- (LONG) Bytes that were really read.
  1975.  
  1976.    NOTE
  1977.  
  1978.    BUGS
  1979.         Currently, the returned length always matches the buffer length,
  1980.         regardless of the number of bytes that were really available.
  1981.  
  1982.         You must not patch this function.
  1983.  
  1984.    SEE ALSO
  1985.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  1986.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend()
  1987.  
  1988.  
  1989. palmlink.library/PL_DLPSend
  1990.  
  1991.    NAME
  1992.         PL_DLPSend - Send a command and the DLP buffer
  1993.  
  1994.    SYNOPSIS
  1995.         Length = PL_DLPSend(Socket,Cmd,Arg)
  1996.          D0.l                A0.l  D0.b D1.b
  1997.  
  1998.         LONG PL_DLPSend(APTR,UBYTE,UBYTE);
  1999.  
  2000.    FUNCTION
  2001.         The current DLP buffer is sent to the Pilot, and the provided
  2002.         command is executed. The reply packet is stored into the DLP
  2003.         buffer; its size is returned.
  2004.  
  2005.         This is a low level call, and is used by the palmlink.library
  2006.         itself. Usually, you do not need to use this function.
  2007.  
  2008.    INPUTS
  2009.         Socket        -- (APTR) Socket
  2010.         Cmd           -- (UBYTE) Command code to be executed
  2011.         Arg           -- (UBYTE) Argument to the command
  2012.  
  2013.    RESULT
  2014.         Length        -- (LONG) Length of the received reply. 0 if
  2015.                 the call succeeded but no reply was sent. -1 if the
  2016.                 call failed (see PL_LastError()).
  2017.  
  2018.    NOTE
  2019.  
  2020.    BUGS
  2021.         You must not patch this function.
  2022.  
  2023.    SEE ALSO
  2024.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2025.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPRead()
  2026.  
  2027.  
  2028. palmlink.library/PL_DLPTstWrite
  2029.  
  2030.    NAME
  2031.         PL_DLPTstWrite - Test if there is sufficient space in the DLP buffer
  2032.  
  2033.    SYNOPSIS
  2034.         Success = PL_DLPTstWrite(Socket,Length)
  2035.           D0.l                    A0.l   D0.l
  2036.  
  2037.         int PL_DLPTstWrite(APTR,LONG);
  2038.  
  2039.    FUNCTION
  2040.         It is tested if a structure with the passed size will fit into
  2041.         the current DLP buffer.
  2042.  
  2043.         This is a low level call, and is used by the palmlink.library
  2044.         itself. Usually, you do not need to use this function.
  2045.  
  2046.    INPUTS
  2047.         Socket        -- (APTR) Socket
  2048.         Length        -- (LONG) Length of the structure
  2049.  
  2050.    RESULT
  2051.         Success       -- (int) TRUE: There is enough space left
  2052.  
  2053.    NOTE
  2054.  
  2055.    BUGS
  2056.         You must not patch this function.
  2057.  
  2058.    SEE ALSO
  2059.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2060.         PL_DLPWriteLong(), PL_DLPWrite(), PL_DLPSend(), PL_DLPRead()
  2061.  
  2062.  
  2063. palmlink.library/PL_DLPWrite
  2064.  
  2065.    NAME
  2066.         PL_DLPWrite - Write a structure to the DLP buffer
  2067.  
  2068.    SYNOPSIS
  2069.         Length = PL_DLPWrite(Socket,Structure,Length)
  2070.          D0.l                 A0.l    A1.l     D0.l
  2071.  
  2072.         LONG PL_DLPWrite(APTR,APTR,LONG);
  2073.  
  2074.    FUNCTION
  2075.         The provided structure is added to the DLP buffer.
  2076.  
  2077.         This is a low level call, and is used by the palmlink.library
  2078.         itself. Usually, you do not need to use this function.
  2079.  
  2080.    INPUTS
  2081.         Socket        -- (APTR) Socket
  2082.         Structure     -- (APTR) Data structure to be added
  2083.         Length        -- (LONG) Length of the structure
  2084.  
  2085.    RESULT
  2086.         Length        -- (LONG) Current length of the DLP packet
  2087.  
  2088.    NOTE
  2089.  
  2090.    BUGS
  2091.         PalmLink does not check if the structure really fit into
  2092.         the remaining DLP buffer space. If you are in doubt, use
  2093.         PL_DLPTstWrite() before.
  2094.  
  2095.         You must not patch this function.
  2096.  
  2097.    SEE ALSO
  2098.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2099.         PL_DLPWriteLong(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2100.  
  2101.  
  2102. palmlink.library/PL_DLPWriteByte
  2103.  
  2104.    NAME
  2105.         PL_DLPWriteByte - Write a byte to the DLP buffer
  2106.  
  2107.    SYNOPSIS
  2108.         Length = PL_DLPWriteByte(Socket,Data)
  2109.          D0.l                     A0.l  D0.b
  2110.  
  2111.         LONG PL_DLPWriteByte(APTR,BYTE);
  2112.  
  2113.    FUNCTION
  2114.         The provided byte is added to the DLP buffer.
  2115.  
  2116.         This is a low level call, and is used by the palmlink.library
  2117.         itself. Usually, you do not need to use this function.
  2118.  
  2119.    INPUTS
  2120.         Socket        -- (APTR) Socket
  2121.         Data          -- (BYTE) Data to be added
  2122.  
  2123.    RESULT
  2124.         Length        -- (LONG) Current length of the DLP packet
  2125.  
  2126.    NOTE
  2127.  
  2128.    BUGS
  2129.         You must not patch this function.
  2130.  
  2131.    SEE ALSO
  2132.         PL_DLPInit(), PL_DLPWriteWord(), PL_DLPWriteLong(),
  2133.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2134.  
  2135.  
  2136. palmlink.library/PL_DLPWriteLong
  2137.  
  2138.    NAME
  2139.         PL_DLPWriteLong - Write a longword to the DLP buffer
  2140.  
  2141.    SYNOPSIS
  2142.         Length = PL_DLPWriteLong(Socket,Data)
  2143.          D0.l                     A0.l  D0.l
  2144.  
  2145.         LONG PL_DLPWriteLong(APTR,LONG);
  2146.  
  2147.    FUNCTION
  2148.         The provided longword is added to the DLP buffer.
  2149.  
  2150.         This is a low level call, and is used by the palmlink.library
  2151.         itself. Usually, you do not need to use this function.
  2152.  
  2153.    INPUTS
  2154.         Socket        -- (APTR) Socket
  2155.         Data          -- (BYTE) Data to be added
  2156.  
  2157.    RESULT
  2158.         Length        -- (LONG) Current length of the DLP packet
  2159.  
  2160.    NOTE
  2161.  
  2162.    BUGS
  2163.         You must not patch this function.
  2164.  
  2165.    SEE ALSO
  2166.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteWord(),
  2167.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2168.  
  2169.  
  2170. palmlink.library/PL_DLPWriteWord
  2171.  
  2172.    NAME
  2173.         PL_DLPWriteWord - Write a word to the DLP buffer
  2174.  
  2175.    SYNOPSIS
  2176.         Length = PL_DLPWriteWord(Socket,Data)
  2177.          D0.l                     A0.l  D0.w
  2178.  
  2179.         LONG PL_DLPWriteWord(APTR,WORD);
  2180.  
  2181.    FUNCTION
  2182.         The provided word is added to the DLP buffer.
  2183.  
  2184.         This is a low level call, and is used by the palmlink.library
  2185.         itself. Usually, you do not need to use this function.
  2186.  
  2187.    INPUTS
  2188.         Socket        -- (APTR) Socket
  2189.         Data          -- (BYTE) Data to be added
  2190.  
  2191.    RESULT
  2192.         Length        -- (LONG) Current length of the DLP packet
  2193.  
  2194.    NOTE
  2195.  
  2196.    BUGS
  2197.         You must not patch this function.
  2198.  
  2199.    SEE ALSO
  2200.         PL_DLPInit(), PL_DLPWriteByte(), PL_DLPWriteLong(),
  2201.         PL_DLPWrite(), PL_DLPTstWrite(), PL_DLPSend(), PL_DLPRead()
  2202.  
  2203.  
  2204. palmlink.library/PL_Explain
  2205.  
  2206.    NAME
  2207.         PL_Explain - Explain an error code
  2208.  
  2209.    SYNOPSIS
  2210.         PL_Explain(Error,Buffer,Length)
  2211.                     A0.l  A1.l   D0.w
  2212.  
  2213.         void PL_Explain(LONG,STRPTR,ULONG);
  2214.  
  2215.    FUNCTION
  2216.         Explains the provided error code. The explanation is copied
  2217.         into the buffer space, until Length is reached.
  2218.  
  2219.         If the error was a DOS error code, it will be explained as
  2220.         well, using dos.library.
  2221.  
  2222.    INPUTS
  2223.         Error         -- (LONG) Error code to be explained
  2224.         Buffer        -- (STRPTR) Buffer for the explanation
  2225.         Length        -- (ULONG) Maximum buffer size, including the
  2226.                 null termination.
  2227.  
  2228.    RESULT
  2229.  
  2230.    NOTE
  2231.  
  2232.    BUGS
  2233.         The error code is provided in A0, not in a data register.
  2234.         Anyhow, for compatibility reasons, this will be kept like that.
  2235.  
  2236.    SEE ALSO
  2237.  
  2238.  
  2239. palmlink.library/PL_FileAddRecord
  2240.  
  2241.    NAME
  2242.         PL_FileAddRecord - add a record to a new file
  2243.  
  2244.    SYNOPSIS
  2245.         Success = PL_FileAddRecord(FileHandle,Buffer,Size,Attr,UID)
  2246.           D0.l                         A0.l    A1.l  D0.l D1.b D2.l
  2247.  
  2248.         int PL_FileAddRecord(APTR,APTR,ULONG,UBYTE,ULONG);
  2249.  
  2250.    FUNCTION
  2251.         Write mode: add a record to the file.
  2252.  
  2253.    INPUTS
  2254.         FileHandle    -- (APTR) Handle of the file
  2255.         Buffer        -- (APTR) Buffer containing the record data.
  2256.                 This buffer will be copied and can be changed after
  2257.                 that.
  2258.         Size          -- (ULONG) Size of the record data.
  2259.         Attr          -- (UBYTE) Record attribute. The attribute consists
  2260.                 of the attribute itself (upper nibble, 0xF0) and the category
  2261.                 ID (lower nibble, 0x0F).
  2262.         UID           -- (ULONG) Record UID. Only the lower 3 bytes are used.
  2263.  
  2264.    RESULT
  2265.         Success       -- (int) TRUE: The new record has been added
  2266.                 successfully.
  2267.  
  2268.    NOTE
  2269.  
  2270.    BUGS
  2271.         Currently, there is no way to find out the reason why this function
  2272.         failed.
  2273.  
  2274.    SEE ALSO
  2275.  
  2276. palmlink.library/PL_FileAddResorce
  2277.  
  2278.    NAME
  2279.         PL_FileAddResource - add a resource to a new file
  2280.  
  2281.    SYNOPSIS
  2282.         Success = PL_FileAddResource(FileHandle,Buffer,Size,Type,ID)
  2283.           D0.l                           A0.l    A1.l  D0.l D1.l D2.w
  2284.  
  2285.         int PL_FileAddResource(APTR,APTR,ULONG,ULONG,UWORD);
  2286.  
  2287.    FUNCTION
  2288.         Write mode: add a resource to the file.
  2289.  
  2290.    INPUTS
  2291.         FileHandle    -- (APTR) Handle of the file
  2292.         Buffer        -- (APTR) Buffer containing the resource data.
  2293.                 This buffer will be copied and can be changed after
  2294.                 that.
  2295.         Size          -- (ULONG) Size of the resource data.
  2296.         Type          -- (ULONG) Resource Type
  2297.         ID            -- (UWORD) Resource ID
  2298.  
  2299.    RESULT
  2300.         Success       -- (int) TRUE: The new resource has been added
  2301.                 successfully.
  2302.  
  2303.    NOTE
  2304.  
  2305.    BUGS
  2306.         Currently, there is no way to find out the reason why this function
  2307.         failed.
  2308.  
  2309.    SEE ALSO
  2310.  
  2311. palmlink.library/PL_FileClose
  2312.  
  2313.    NAME
  2314.         PL_FileClose - close a .prc or .pdb file
  2315.  
  2316.    SYNOPSIS
  2317.         Success = PL_FileClose(FileHandle)
  2318.          D0.l                    A0.l
  2319.  
  2320.         int PL_FileClose(APTR);
  2321.  
  2322.    FUNCTION
  2323.         Close a .prc or .pdb file. If the file was openened for writing,
  2324.         it will be created on close. Thus, if the file couldn't be written,
  2325.         the error will occur here!
  2326.  
  2327.    INPUTS
  2328.         FileHandle    -- (APTR) FileHandle to close.
  2329.  
  2330.    RESULT
  2331.         Success       -- (int) TRUE: File was closed successfully
  2332.  
  2333.    NOTE
  2334.  
  2335.    BUGS
  2336.         Currently, there is no way to find out the reason why this function
  2337.         failed.
  2338.  
  2339.    SEE ALSO
  2340.  
  2341. palmlink.library/PL_FileGetAppInfo
  2342.  
  2343.    NAME
  2344.         PL_FileGetAppInfo - get the application info of this file
  2345.  
  2346.    SYNOPSIS
  2347.         AppInfo = PL_FileGetAppInfo(FileHandle,Size)
  2348.           D0.l                       A0.l      A1.l
  2349.  
  2350.         APTR PL_FileGetAppInfo(APTR,ULONG *);
  2351.  
  2352.    FUNCTION
  2353.         Read mode: Get the application info of the current file.
  2354.  
  2355.    INPUTS
  2356.         FileHandle    -- (APTR) Filehandle of the file
  2357.         Size          -- (ULONG *) The size of the AppInfo is
  2358.                 written into the referenced ULONG.
  2359.  
  2360.    RESULT
  2361.         AppInfo       -- (APTR) Application info of the file.
  2362.                 This structure is READ ONLY!
  2363.  
  2364.    NOTE
  2365.  
  2366.    BUGS
  2367.  
  2368.    SEE ALSO
  2369.  
  2370. palmlink.library/PL_FileGetDBInfo
  2371.  
  2372.    NAME
  2373.         PL_FileGetDBInfo - get the database info of this file
  2374.  
  2375.    SYNOPSIS
  2376.         DBInfo = PL_FileGetDBInfo(FileHandle)
  2377.          D0.l                        A0.l
  2378.  
  2379.         struct DLP_DBInfo *PL_FileGetDBInfo(APTR);
  2380.  
  2381.    FUNCTION
  2382.         Read mode: Get the database info of the current file.
  2383.  
  2384.    INPUTS
  2385.         FileHandle    -- (APTR) Filehandle of the file
  2386.  
  2387.    RESULT
  2388.         DBInfo        -- (struct DLP_DBInfo *) DBInfo of the file.
  2389.                 This structure is READ ONLY!
  2390.  
  2391.    NOTE
  2392.  
  2393.    BUGS
  2394.  
  2395.    SEE ALSO
  2396.  
  2397. palmlink.library/PL_FileGetSortInfo
  2398.  
  2399.    NAME
  2400.         PL_FileGetSortInfo - get the sort info of this file
  2401.  
  2402.    SYNOPSIS
  2403.         SortInfo = PL_FileGetSortInfo(FileHandle,Size)
  2404.           D0.l                         A0.l      A1.l
  2405.  
  2406.         APTR PL_FileGetSortInfo(APTR,ULONG *);
  2407.  
  2408.    FUNCTION
  2409.         Read mode: Get the sort info of the current file.
  2410.  
  2411.    INPUTS
  2412.         FileHandle    -- (APTR) Filehandle of the file
  2413.         Size          -- (ULONG *) The size of the SortInfo is
  2414.                 written into the referenced ULONG.
  2415.  
  2416.    RESULT
  2417.         SortInfo      -- (APTR) Sort info of the file.
  2418.                 This structure is READ ONLY!
  2419.  
  2420.    NOTE
  2421.  
  2422.    BUGS
  2423.  
  2424.    SEE ALSO
  2425.  
  2426. palmlink.library/PL_FileInstall
  2427.  
  2428.    NAME
  2429.         PL_FileInstall - copy a database into the Pilot
  2430.  
  2431.    SYNOPSIS
  2432.         Success = PL_FileInstall(FileHandle,Socket,CardNo)
  2433.          D0.l                       A0.l      A1.l   D0.b
  2434.  
  2435.         int PL_FileInstall(APTR,APTR,UBYTE);
  2436.  
  2437.    FUNCTION
  2438.         Copy a database from this file into the PalmPilot. The database is
  2439.         selected via the current DBInfo.
  2440.  
  2441.    INPUTS
  2442.         FileHandle    -- (APTR) FileHandle
  2443.         Socket        -- (APTR) Socket, connection to the Pilot
  2444.         CardNo        -- (UBYTE) CardNo of the database
  2445.  
  2446.    RESULT
  2447.         Success       -- (int) TRUE: All data have been written successfully
  2448.  
  2449.    NOTE
  2450.         All socket errors can be read using PL_LastError().
  2451.  
  2452.    BUGS
  2453.         Currently, there is no way to find out the reason why this function
  2454.         failed.
  2455.  
  2456.    SEE ALSO
  2457.  
  2458. palmlink.library/PL_FileMerge
  2459.  
  2460.    NAME
  2461.         PL_FileMerge - copy a database into the Pilot, keep old data
  2462.  
  2463.    SYNOPSIS
  2464.         Success = PL_FileMerge(FileHandle,Socket,CardNo)
  2465.          D0.l                    A0.l      A1.l   D0.b
  2466.  
  2467.         int PL_FileMerge(APTR,APTR,UBYTE);
  2468.  
  2469.    FUNCTION
  2470.         Copy a database from this file into the PalmPilot. All old data
  2471.         are kept, so new records are added to existing ones. The database is
  2472.         selected via the current DBInfo.
  2473.  
  2474.    INPUTS
  2475.         FileHandle    -- (APTR) FileHandle
  2476.         Socket        -- (APTR) Socket, connection to the Pilot
  2477.         CardNo        -- (UBYTE) CardNo of the database
  2478.  
  2479.    RESULT
  2480.         Success       -- (int) TRUE: All data have been merged successfully
  2481.  
  2482.    NOTE
  2483.         All socket errors can be read using PL_LastError().
  2484.  
  2485.    BUGS
  2486.         Currently, there is no way to find out the reason why this function
  2487.         failed.
  2488.  
  2489.    SEE ALSO
  2490.  
  2491. palmlink.library/PL_FileOpen
  2492.  
  2493.    NAME
  2494.         PL_FileOpen - open a .prc or .pdb file
  2495.  
  2496.    SYNOPSIS
  2497.         FileHandle = PL_FileOpen(Name,DBInfo)
  2498.           D0.l                   A0.l  A1.l
  2499.  
  2500.         APTR PL_FileOpen(STRPTR,struct DLP_DBInfo *);
  2501.  
  2502.    FUNCTION
  2503.         Open a .prc or .pdb file and grant a database like access to it.
  2504.         The file is opened for reading if no DBInfo is provided (NULL),
  2505.         else it is opened for writing.
  2506.  
  2507.    INPUTS
  2508.         Name          -- (STRPTR) Name of the DOS file
  2509.         DBInfo        -- (struct DLP_DBInfo *) Database info for the
  2510.                 file to write, or NULL for read access.
  2511.  
  2512.    RESULT
  2513.         FileHandle    -- (APTR) Filehandle for this file, or NULL if
  2514.                 an error occured.
  2515.  
  2516.    NOTE
  2517.  
  2518.    BUGS
  2519.         Currently, there is no way to find out the reason why this function
  2520.         failed.
  2521.  
  2522.    SEE ALSO
  2523.  
  2524. palmlink.library/PL_FileReadRecord
  2525.  
  2526.    NAME
  2527.         PL_FileReadRecord - read a record
  2528.  
  2529.    SYNOPSIS
  2530.         Record = PL_FileReadRecord(FileHandle,Index,Size,Attr,UID)
  2531.          D0.l                         A0.l     D0.w A1.l A2.l A3.l
  2532.  
  2533.         APTR PL_FileReadRecord(APTR,UWORD,ULONG *,UBYTE *,ULONG *);
  2534.  
  2535.    FUNCTION
  2536.         Read a record out of the file.
  2537.  
  2538.    INPUTS
  2539.         FileHandle    -- (APTR) Handle of the file
  2540.         Index         -- (UWORD) Index of the record
  2541.         Size          -- (ULONG *) The size of the record is stored into
  2542.                 this ULONG reference.
  2543.         Attr          -- (UBYTE *) The attribute of the record is stored
  2544.                 into this UBYTE reference. The attribute consists of the
  2545.                 attribute itself (upper nibble, 0xF0) and the category
  2546.                 ID (lower nibble, 0x0F).
  2547.         UID           -- (ULONG *) The UID of the record is stored into
  2548.                 this ULONG reference. Only the lower 3 bytes are used.
  2549.  
  2550.    RESULT
  2551.         Record        -- (APTR) Record data. This data is READ ONLY.
  2552.  
  2553.    NOTE
  2554.  
  2555.    BUGS
  2556.         Currently, there is no way to find out the reason why this function
  2557.         failed.
  2558.  
  2559.    SEE ALSO
  2560.  
  2561. palmlink.library/PL_FileReadRecordID
  2562.  
  2563.    NAME
  2564.         PL_FileReadRecordID - read a record by its UID
  2565.  
  2566.    SYNOPSIS
  2567.         Record = PL_FileReadRecordID(FileHandle,UID,Size,Attr,Index)
  2568.          D0.l                         A0.l     D0.l A1.l A2.l A3.l
  2569.  
  2570.         APTR PL_FileReadRecordID(APTR,ULONG,ULONG *,UBYTE *,UWORD *);
  2571.  
  2572.    FUNCTION
  2573.         Read a record out of the file, by its UID.
  2574.  
  2575.    INPUTS
  2576.         FileHandle    -- (APTR) Handle of the file
  2577.         UID           -- (ULONG) The UID of the desired record.
  2578.         Size          -- (ULONG *) The size of the record is stored into
  2579.                 this ULONG reference.
  2580.         Attr          -- (UBYTE *) The attribute of the record is stored
  2581.                 into this UBYTE reference. The attribute consists of the
  2582.                 attribute itself (upper nibble, 0xF0) and the category
  2583.                 ID (lower nibble, 0x0F).
  2584.         Index         -- (UWORD *) The index of the record is stored into
  2585.                 this UWORD reference.
  2586.  
  2587.    RESULT
  2588.         Record        -- (APTR) Record data. This data is READ ONLY.
  2589.  
  2590.    NOTE
  2591.  
  2592.    BUGS
  2593.         Currently, there is no way to find out the reason why this function
  2594.         failed.
  2595.  
  2596.    SEE ALSO
  2597.  
  2598. palmlink.library/PL_FileReadResorce
  2599.  
  2600.    NAME
  2601.         PL_FileReadResource - read a resource
  2602.  
  2603.    SYNOPSIS
  2604.         Resource = PL_FileReadResource(FileHandle,Index,Size,Type,ID)
  2605.           D0.l                            A0.l     D0.w A1.l A2.l A3.l
  2606.  
  2607.         APTR PL_FileReadResource(APTR,UWORD,ULONG *,ULONG *,UWORD *);
  2608.  
  2609.    FUNCTION
  2610.         Read a resource out of the file.
  2611.  
  2612.    INPUTS
  2613.         FileHandle    -- (APTR) Handle of the file
  2614.         Index         -- (UWORD) Index of the resource
  2615.         Size          -- (ULONG *) The size of the resource is stored into
  2616.                 this ULONG reference.
  2617.         Type          -- (ULONG *) The type of the resource is stored into
  2618.                 this ULONG reference.
  2619.         ID            -- (UWORD *) The ID of the resource is stored into
  2620.                 this UWORD reference.
  2621.  
  2622.    RESULT
  2623.         Resource      -- (APTR) Resource data. This data is READ ONLY.
  2624.  
  2625.    NOTE
  2626.  
  2627.    BUGS
  2628.         Currently, there is no way to find out the reason why this function
  2629.         failed.
  2630.  
  2631.    SEE ALSO
  2632.  
  2633. palmlink.library/PL_FileRetrieve
  2634.  
  2635.    NAME
  2636.         PL_FileRetrieve - copy a database into the file
  2637.  
  2638.    SYNOPSIS
  2639.         Success = PL_FileRetrieve(FileHandle,Socket,CardNo)
  2640.          D0.l                       A0.l      A1.l   D0.b
  2641.  
  2642.         int PL_FileRetrieve(APTR,APTR,UBYTE);
  2643.  
  2644.    FUNCTION
  2645.         Copy a database from the PalmPilot to this file. The database is
  2646.         selected via the current DBInfo.
  2647.  
  2648.    INPUTS
  2649.         FileHandle    -- (APTR) FileHandle
  2650.         Socket        -- (APTR) Socket, connection to the Pilot
  2651.         CardNo        -- (UBYTE) CardNo of the database
  2652.  
  2653.    RESULT
  2654.         Success       -- (int) TRUE: All data have been read successfully
  2655.  
  2656.    NOTE
  2657.         All socket errors can be read using PL_LastError().
  2658.  
  2659.    BUGS
  2660.         Currently, there is no way to find out the reason why this function
  2661.         failed.
  2662.  
  2663.    SEE ALSO
  2664.  
  2665. palmlink.library/PL_FileSetAppInfo
  2666.  
  2667.    NAME
  2668.         PL_FileSetAppInfo - set the application info of this file
  2669.  
  2670.    SYNOPSIS
  2671.         Success = PL_FileSetAppInfo(FileHandle,AppInfo,Length)
  2672.          D0.l                         A0.l       A1.l   D0.l
  2673.  
  2674.         int PL_FileSetAppInfo(APTR,APTR,ULONG);
  2675.  
  2676.    FUNCTION
  2677.         Write mode only: Set the application info of the current file.
  2678.  
  2679.    INPUTS
  2680.         FileHandle    -- (APTR) Filehandle of the file
  2681.         AppInfo       -- (APTR) Application info to be set
  2682.         Length        -- (ULONG) Length of the application info
  2683.  
  2684.    RESULT
  2685.         Success       -- (int) TRUE if AppInfo has been set successfully.
  2686.  
  2687.    NOTE
  2688.  
  2689.    BUGS
  2690.         Currently, there is no way to find out the reason why this function
  2691.         failed.
  2692.  
  2693.    SEE ALSO
  2694.  
  2695. palmlink.library/PL_FileSetDBInfo
  2696.  
  2697.    NAME
  2698.         PL_FileSetDBInfo - set the database info of this file
  2699.  
  2700.    SYNOPSIS
  2701.         Success = PL_FileSetDBInfo(FileHandle,DBInfo)
  2702.          D0.l                        A0.l      A1.l
  2703.  
  2704.         int PL_FileSetDBInfo(APTR,struct DLP_DBInfo *);
  2705.  
  2706.    FUNCTION
  2707.         Write mode only: Set the database info of the current file.
  2708.         If the file was openend as resource file, you must also give
  2709.         a resource DBInfo here (record files appropriately).
  2710.  
  2711.    INPUTS
  2712.         FileHandle    -- (APTR) Filehandle of the file
  2713.         DBInfo        -- (struct DLP_DBInfo *) New DBInfo for the file.
  2714.  
  2715.    RESULT
  2716.         Success       -- (int) TRUE if DBInfo has been set successfully.
  2717.  
  2718.    NOTE
  2719.  
  2720.    BUGS
  2721.         Currently, there is no way to find out the reason why this function
  2722.         failed.
  2723.  
  2724.    SEE ALSO
  2725.  
  2726. palmlink.library/PL_FileSetSortInfo
  2727.  
  2728.    NAME
  2729.         PL_FileSetSortInfo - set the sort info of this file
  2730.  
  2731.    SYNOPSIS
  2732.         Success = PL_FileSetSortInfo(FileHandle,SortInfo,Length)
  2733.          D0.l                         A0.l        A1.l    D0.l
  2734.  
  2735.         int PL_FileSetSortInfo(APTR,APTR,ULONG);
  2736.  
  2737.    FUNCTION
  2738.         Write mode only: Set the sort info of the current file.
  2739.  
  2740.    INPUTS
  2741.         FileHandle    -- (APTR) Filehandle of the file
  2742.         SortInfo      -- (APTR) Sort info to be set
  2743.         Length        -- (ULONG) Length of the sort info
  2744.  
  2745.    RESULT
  2746.         Success       -- (int) TRUE if SortInfo has been set successfully.
  2747.  
  2748.    NOTE
  2749.  
  2750.    BUGS
  2751.         Currently, there is no way to find out the reason why this function
  2752.         failed.
  2753.  
  2754.    SEE ALSO
  2755.  
  2756. palmlink.library/PL_FileUsedID
  2757.  
  2758.    NAME
  2759.         PL_FileUsedID - check if a UID is already in use
  2760.  
  2761.    SYNOPSIS
  2762.         Result = PL_FileUsedID(FileHandle,UID)
  2763.          D0.l                    A0.l     D0.l
  2764.  
  2765.         int PL_FileUsedID(APTR,ULONG);
  2766.  
  2767.    FUNCTION
  2768.         Check if a UID is already in use in this file.
  2769.  
  2770.    INPUTS
  2771.         FileHandle    -- (APTR) FileHandle
  2772.         UID           -- (ULONG) UID to be checked
  2773.  
  2774.    RESULT
  2775.         Result        -- (int) TRUE: UID is in use
  2776.  
  2777.    NOTE
  2778.  
  2779.    BUGS
  2780.  
  2781.    SEE ALSO
  2782.  
  2783. palmlink.library/PL_FindRexxHandle
  2784.  
  2785.    NAME
  2786.         PL_FindRexxHandle - Find an ARexx handle
  2787.  
  2788.    SYNOPSIS
  2789.         Socket = PL_FindRexxHandle(Name)
  2790.          D0.l                      A0.l
  2791.  
  2792.         APTR PL_FindRexxHandle(STRPTR);
  2793.  
  2794.    FUNCTION
  2795.         After a socket has been created by an ARexx function, its handle
  2796.         is maintained by the palmlink.library.
  2797.  
  2798.         This function finds the handle name in the internal list and
  2799.         returns the related socket ptr.
  2800.  
  2801.         If the name did not exist, NULL will be returned.
  2802.  
  2803.    INPUTS
  2804.         Name          -- (STRPTR) Name of the handle
  2805.  
  2806.    RESULT
  2807.         Socket        -- The socket that the name was associated with
  2808.  
  2809.    NOTE
  2810.         This function is meant for PalmLink ARexx library programmers.
  2811.         Do not abuse it for other things, please!
  2812.  
  2813.    BUGS
  2814.  
  2815.    SEE ALSO
  2816.         PL_AddRexxHandle(), PL_DeleteRexxHandle()
  2817.  
  2818. palmlink.library/PL_LastError
  2819.  
  2820.    NAME
  2821.         PL_LastError - return the last error code
  2822.  
  2823.    SYNOPSIS
  2824.         Error = PL_LastError(Socket)
  2825.         D0.l                  A0.l
  2826.  
  2827.         LONG PL_LastError(APTR);
  2828.  
  2829.    FUNCTION
  2830.         Return the code of the last error. Negative codes are PalmLink
  2831.         errors. Positive are DLP error codes. If the error code is
  2832.         PLERR_DOSERROR, you can read dos/IoErr() for the cause.
  2833.  
  2834.    INPUTS
  2835.         Socket        -- (APTR) Socket
  2836.  
  2837.    RESULT
  2838.         Error         -- (LONG) Error code, or PLERR_OKAY if no error
  2839.                          has been occured.
  2840.  
  2841.    NOTE
  2842.  
  2843.    BUGS
  2844.  
  2845.    SEE ALSO
  2846.  
  2847. palmlink.library/PL_OpenSocket
  2848.  
  2849.    NAME
  2850.         PL_OpenSocket - open a socket to a Palm Pilot
  2851.  
  2852.    SYNOPSIS
  2853.         Socket = PL_OpenSocket(TagList)
  2854.         D0.l                    A0.l
  2855.  
  2856.         APTR PL_OpenSocket(struct TagItem *);
  2857.  
  2858.         Socket = PL_OpenSocketTags(Tag1,...)
  2859.  
  2860.         APTR PL_OpenSocketTags(ULONG,...);
  2861.  
  2862.    FUNCTION
  2863.         Open a new socket to a Palm Pilot. The Pilot must be connected to
  2864.         a serial port. As default, the internal serial port is used.
  2865.  
  2866.         If the socket cannot be created, NULL is returned. You can get an
  2867.         explicit error code using the PLTAG_Error tag.
  2868.  
  2869.    INPUTS
  2870.         TagList       -- (struct TagItem *) tags with further options,
  2871.                 or NULL to use all defaults.
  2872.  
  2873.    RESULT
  2874.         Socket        -- (APTR) Pointer to a socket. You must use this
  2875.                 socket for all other functions. NULL if an error occured.
  2876.  
  2877.    TAGS
  2878.         PLTAG_ErrorPtr          -- (LONG *) If an error occured (return code
  2879.                 is NULL), the error code is written into this longword. On
  2880.                 success you will find PLERR_OKAY here.
  2881.  
  2882.         PLTAG_SerialDevice      -- (STRPTR) Name of the serial device to be
  2883.                 used. Defaults to "serial.device". I suggest to use speed
  2884.                 optimized devices, as 8n1.device, to gain maximum transfer
  2885.                 rates between Amiga and Pilot.
  2886.  
  2887.         PLTAG_SerialUnit        -- (LONG) Unit of the serial device. Defaults
  2888.                 to unit 0.
  2889.  
  2890.         PLTAG_SerialMaxRate     -- (ULONG) Maximum baud rate the device can
  2891.                 generate. Defaults to 28800, which is the maximum rate of the
  2892.                 internal serial port common to the Palm Pilot. If you use a
  2893.                 multi serial interface, or faster devices as 8n1.device, you
  2894.                 can go up to 57600.
  2895.  
  2896.         PLTAG_SerialTimeout     -- (ULONG) Time (s) that the serial receiver
  2897.                 waits for a message. If this time passed, a PLERR_TIMEOUT will
  2898.                 be produced. Defaults to 10.
  2899.  
  2900.    NOTE
  2901.  
  2902.    BUGS
  2903.  
  2904.    SEE ALSO
  2905.         PL_CloseSocket()
  2906.  
  2907. palmlink.library/PL_PADPRead
  2908.  
  2909.    NAME
  2910.         PL_PADPRead - read a packet using PADP
  2911.  
  2912.    SYNOPSIS
  2913.         Length = PL_PADPRead(Socket,Buffer,Size)
  2914.         D0.l                  A0.l   A1.l  D0.l
  2915.  
  2916.         LONG PL_PADPRead(APTR,APTR,LONG);
  2917.  
  2918.    FUNCTION
  2919.         Read a data packet from the Palm Pilot, using PADP (Packet
  2920.         Assembly Disassembly Protocol). This function returns the number
  2921.         of bytes that were received, or -1 if an error occured. You can
  2922.         read the error code using PL_LastError().
  2923.  
  2924.         This is a low level call, and is used by the palmlink.library
  2925.         itself. Usually, you do not need to use this function.
  2926.  
  2927.    INPUTS
  2928.         Socket        -- (APTR) Socket
  2929.         Buffer        -- (APTR) Data buffer space
  2930.         Size          -- (LONG) Length of buffer space
  2931.  
  2932.    RESULT
  2933.         Length        -- (LONG) Received bytes, or -1: error
  2934.  
  2935.    NOTE
  2936.  
  2937.    BUGS
  2938.  
  2939.    SEE ALSO
  2940.         PL_PADPWrite()
  2941.  
  2942.  
  2943. palmlink.library/PL_PADPWrite
  2944.  
  2945.    NAME
  2946.         PL_PADPWrite - write a PADP packet to the Palm Pilot
  2947.  
  2948.    SYNOPSIS
  2949.         Length = PL_PADPWrite(Socket,Buffer,Length,Type)
  2950.         D0.l                   A0.l   A1.l   D0.l  D1.w
  2951.  
  2952.         LONG PL_PADPWrite(APTR,APTR,LONG,UWORD);
  2953.  
  2954.    FUNCTION
  2955.         Write a data packet to the Palm Pilot. The packet is sent using
  2956.         the PADP (Packet Assembly Disassembly Protocol). This function
  2957.         returns the number of bytes sent, or -1 if an error occured. You
  2958.         can read the error code using PL_LastError().
  2959.  
  2960.         This is a low level call, and is used by the palmlink.library
  2961.         itself. Usually, you do not need to use this function.
  2962.  
  2963.    INPUTS
  2964.         Socket        -- (APTR) Socket
  2965.         Buffer        -- (APTR) Buffer of data to be transmitted
  2966.         Length        -- (LONG) Number of bytes to send
  2967.         Type          -- (UWORD) Packet type:
  2968.                 PLPADP_DATA     - A plain data packet. This is the most
  2969.                         commonly used packet type.
  2970.                 PLPADP_WAKE     - A wakeup packet. Usually only for
  2971.                         PalmLink internal use.
  2972.                 PLPADP_ACK      - An acknowledge packet. Usually generated
  2973.                         and sent by PalmLink. You don't need to generate
  2974.                         acknowledgements.
  2975.                 PLPADP_TICKLE   - A tickle packet. Used by PL_Tickle().
  2976.                 PLPADP_ABORT    - An abortion packet (PalmOS 2.0 or higher)
  2977.  
  2978.    RESULT
  2979.         Length        -- (LONG) Bytes sent, or -1: error
  2980.  
  2981.    NOTE
  2982.  
  2983.    BUGS
  2984.  
  2985.    SEE ALSO
  2986.         PL_PADPRead()
  2987.  
  2988. palmlink.library/PL_RawRead
  2989.  
  2990.    NAME
  2991.         PL_RawRead - read raw data from the serial interface
  2992.  
  2993.    SYNOPSIS
  2994.         Length = PL_RawRead(Socket,Buffer,Length)
  2995.         D0.l                 A0.l   A1.l   D0.l
  2996.  
  2997.         LONG PL_RawRead(APTR,APTR,LONG);
  2998.  
  2999.    FUNCTION
  3000.         Read raw data from the serial interface, until the buffer is
  3001.         filled or the timeout has been reached. If an error occured,
  3002.         you can use PL_LastError() to find out the cause.
  3003.  
  3004.         This is a low level call, and is used by the palmlink.library
  3005.         itself. Usually, you do not need to use this function.
  3006.  
  3007.    INPUTS
  3008.         Socket        -- (APTR) Socket
  3009.         Buffer        -- (APTR) Data buffer space
  3010.         Length        -- (LONG) Length of buffer space
  3011.  
  3012.    RESULT
  3013.         Length        -- (LONG) Number of bytes read, or 0 if an
  3014.                 error occured.
  3015.  
  3016.    NOTE
  3017.  
  3018.    BUGS
  3019.  
  3020.    SEE ALSO
  3021.         PL_RawWrite(), PL_RawSetBaud()
  3022.  
  3023.  
  3024. palmlink.library/PL_RawSetRate
  3025.  
  3026.    NAME
  3027.         PL_RawSetRate - set the serial interface baud rate
  3028.  
  3029.    SYNOPSIS
  3030.         success = PL_RawSetRate(Socket,Rate)
  3031.         D0.l                     A0.l  D0.l
  3032.  
  3033.         int PL_RawSetRate(APTR,ULONG);
  3034.  
  3035.    FUNCTION
  3036.         Sets the serial interface to the new rate. The default baud
  3037.         rate is 9600 Baud. Other (higher) baud rates are arranged between
  3038.         Amiga and Palm Pilot during initialisation, using CMP.
  3039.  
  3040.         This is a low level call, and is used by the palmlink.library
  3041.         itself. Usually, you do not need to use this function.
  3042.  
  3043.    INPUTS
  3044.         Socket        -- (APTR) Socket
  3045.         Rate          -- (ULONG) New rate in bps.
  3046.  
  3047.    RESULT
  3048.         success       -- (int) TRUE if the rate has been set success-
  3049.                 fully, FALSE on error.
  3050.  
  3051.    NOTE
  3052.  
  3053.    BUGS
  3054.  
  3055.    SEE ALSO
  3056.         PL_RawRead(), PL_RawWrite()
  3057.  
  3058.  
  3059. palmlink.library/PL_RawWrite
  3060.  
  3061.    NAME
  3062.         PL_RawWrite - write raw data to the serial interface
  3063.  
  3064.    SYNOPSIS
  3065.         Length = PL_RawWrite(Socket,Buffer,Length)
  3066.         D0.l                  A0.l   A1.l   D0.l
  3067.  
  3068.         LONG PL_RawWrite(APTR,APTR,LONG);
  3069.  
  3070.    FUNCTION
  3071.         Write raw data to the serial interface. If an error occured,
  3072.         you can use PL_LastError() to find out the cause.
  3073.  
  3074.         This is a low level call, and is used by the palmlink.library
  3075.         itself. Usually, you do not need to use this function.
  3076.  
  3077.    INPUTS
  3078.         Socket        -- (APTR) Socket
  3079.         Buffer        -- (APTR) Data buffer
  3080.         Length        -- (LONG) Length of data
  3081.  
  3082.    RESULT
  3083.         Length        -- (LONG) Number of data that were sent, or
  3084.                 0 if an error occured.
  3085.  
  3086.    NOTE
  3087.  
  3088.    BUGS
  3089.  
  3090.    SEE ALSO
  3091.         PL_RawRead(), PL_RawSetBaud()
  3092.  
  3093.  
  3094. palmlink.library/PL_Read
  3095.  
  3096.    NAME
  3097.         PL_Read - read a packet from the Palm Pilot
  3098.  
  3099.    SYNOPSIS
  3100.         Length = PL_Read(Socket,Buffer,Size)
  3101.         D0.l              A0.l   A1.l  D0.l
  3102.  
  3103.         LONG PL_Read(APTR,UBYTE *,LONG);
  3104.  
  3105.    FUNCTION
  3106.         Read a data packet from the Palm Pilot. DLP packets are received
  3107.         through the PADP layer, and require an established connection. This
  3108.         function returns the number of bytes that were received (i.e. the
  3109.         size of the packet), or -1 if an error occured. You can read the
  3110.         error code using PL_LastError().
  3111.  
  3112.    INPUTS
  3113.         Socket        -- (APTR) Socket
  3114.         Buffer        -- (UBYTE *) Data buffer space
  3115.         Size          -- (LONG) Length of buffer space
  3116.  
  3117.    RESULT
  3118.         Length        -- (LONG) Received bytes, or -1: error
  3119.  
  3120.    NOTE
  3121.         The maximum data packet size is 65536 byte.
  3122.  
  3123.    BUGS
  3124.  
  3125.    SEE ALSO
  3126.         PL_Write()
  3127.  
  3128.  
  3129. palmlink.library/PL_SLPRead
  3130.  
  3131.    NAME
  3132.         PL_SLPRead - read a packet using SLP
  3133.  
  3134.    SYNOPSIS
  3135.         Length = PL_SLPRead(Socket,Buffer,Size,Header,PADP)
  3136.         D0.l                 A0.l   A1.l  D0.l  A2.l  A3.l
  3137.  
  3138.         LONG PL_SLPRead(APTR,APTR,LONG,struct PL_SLP_Header *,struct PL_PADP_Header *);
  3139.  
  3140.    FUNCTION
  3141.         Read a data packet from the Palm Pilot, using SLP (Serial Link
  3142.         Protocol). The SLP header is returned in the space passed in
  3143.         Header. You must provide sufficient space here!
  3144.  
  3145.         Additionally, you may provide space for a PADP header, which will
  3146.         later contain the PADP header of the received packet. This is used
  3147.         by PL_PADPRead and enables to read the packet data directly to the
  3148.         destination instead into a buffer. If there is no PADP header, or
  3149.         if you don't want to read it separately, provide NULL here.
  3150.  
  3151.         This function returns the number of bytes that were received, or
  3152.         -1 if an error occured. You can read the error code using
  3153.         PL_LastError().
  3154.  
  3155.         This is a low level call, and is used by the palmlink.library
  3156.         itself. Usually, you do not need to use this function.
  3157.  
  3158.    INPUTS
  3159.         Socket        -- (APTR) Socket
  3160.         Buffer        -- (APTR) Data buffer space
  3161.         Size          -- (LONG) Length of buffer space
  3162.         Header        -- (struct PL_SLP_Header *) Pointer to a space
  3163.                 that will contain the SLP header hereafter.
  3164.         PADP          -- (struct PL_PADP_Header *) Pointer to a space
  3165.                 for the PADP header, or NULL.
  3166.  
  3167.    RESULT
  3168.         Length        -- (LONG) Received bytes, or -1: error
  3169.                 If a PADP header was provided, its size is not included
  3170.                 in this length.
  3171.  
  3172.    NOTE
  3173.  
  3174.    BUGS
  3175.         If the data buffer is not sufficient, a PLERR_CHECKSUM error will
  3176.         be produced, and the stream must be re-synchronized to the next
  3177.         packet, which could fail. So better make sure that at least 1024
  3178.         byte are available, since this is the maximum packet size that can
  3179.         be transported by SLP.
  3180.  
  3181.    SEE ALSO
  3182.         PL_SLPWrite()
  3183.  
  3184.  
  3185. palmlink.library/PL_SLPWrite
  3186.  
  3187.    NAME
  3188.         PL_SLPWrite - write a SLP packet to the Palm Pilot
  3189.  
  3190.    SYNOPSIS
  3191.         Length = PL_SLPWrite(Socket,Buffer,Length,Header,PADP)
  3192.         D0.l                  A0.l   A1.l   D0.l   A2.l  A3.l
  3193.  
  3194.         LONG PL_SLPWrite(APTR,APTR,LONG,struct PL_SLP_Header *, struct PL_PADP_Header *);
  3195.  
  3196.    FUNCTION
  3197.         Write a data packet to the Palm Pilot. The packet is sent using
  3198.         SLP (Serial Link Protocol). The provided SLP header will be wrapped
  3199.         around the packet. Some parts of the SLP header are generated by
  3200.         this call automatically (see includes).
  3201.  
  3202.         Additionally, you may provide a PADP header, which will be wrapped
  3203.         around the data packet as well. This is used by PL_PADPWrite and
  3204.         allows to send the packet data from the source buffer directly,
  3205.         without the need to copy it into a buffer first. If there is no
  3206.         PADP header, or if you don't want to send it separately, provide
  3207.         NULL here.
  3208.  
  3209.         This function returns the number of sent bytes, or -1 if an error
  3210.         occured. You can read the error code using PL_LastError().
  3211.  
  3212.         This is a low level call, and is used by the palmlink.library
  3213.         itself. Usually, you do not need to use this function.
  3214.  
  3215.    INPUTS
  3216.         Socket        -- (APTR) Socket
  3217.         Buffer        -- (APTR) Buffer of data to be transmitted
  3218.         Length        -- (LONG) Bytes to send. If a PADP header is provided,
  3219.                 do *not* add its size here.
  3220.         Header        -- (struct PL_SLP_Header *) SLP header to be
  3221.                 transmitted. Do not pass NULL here!
  3222.         PADP          -- (struct PL_PADP_Header *) PADP header to be
  3223.                 transmitted, or NULL.
  3224.  
  3225.    RESULT
  3226.         Length        -- (LONG) Bytes sent (PADP header not included),
  3227.                 or -1: error
  3228.  
  3229.    NOTE
  3230.  
  3231.    BUGS
  3232.  
  3233.    SEE ALSO
  3234.         PL_SLPRead()
  3235.  
  3236. palmlink.library/PL_Tickle
  3237.  
  3238.    NAME
  3239.         PL_Tickle - tickle the connection
  3240.  
  3241.    SYNOPSIS
  3242.         success = PL_Tickle(Socket)
  3243.         D0.l                A0.l
  3244.  
  3245.         int PL_Tickle(APTR);
  3246.  
  3247.    FUNCTION
  3248.         Tickles the Palm Pilot connection. I assume this prevents some kind
  3249.         of connection timeout. You will not need this call under normal
  3250.         circumstances.
  3251.  
  3252.    INPUTS
  3253.         Socket        -- (APTR) Socket
  3254.  
  3255.    RESULT
  3256.         success       -- (int) FALSE if an error occured. See PL_LastError()
  3257.                 to get the cause.
  3258.  
  3259.    NOTE
  3260.  
  3261.    BUGS
  3262.  
  3263.    SEE ALSO
  3264.  
  3265.  
  3266. palmlink.library/PL_Write
  3267.  
  3268.    NAME
  3269.         PL_Write - write a packet to the Palm Pilot
  3270.  
  3271.    SYNOPSIS
  3272.         Length = PL_Write(Socket,Buffer,Length)
  3273.         D0.l               A0.l   A1.l   D0.l
  3274.  
  3275.         LONG PL_Write(APTR,UBYTE *,LONG);
  3276.  
  3277.    FUNCTION
  3278.         Write a data packet to the Palm Pilot. DLP packets are sent through
  3279.         the PADP layer. This function returns the number of bytes that were
  3280.         sent, or -1 if an error occured. You can read the error code using
  3281.         PL_LastError().
  3282.  
  3283.    INPUTS
  3284.         Socket        -- (APTR) Socket
  3285.         Buffer        -- (UBYTE *) Buffer of data to be transmitted
  3286.         Length        -- (LONG) Bytes to send
  3287.  
  3288.    RESULT
  3289.         Length        -- (LONG) Bytes sent, or -1: error
  3290.  
  3291.    NOTE
  3292.         The maximum data packet size is 65536 byte.
  3293.  
  3294.    BUGS
  3295.  
  3296.    SEE ALSO
  3297.         PL_Read()
  3298.  
  3299.  
  3300.