home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 24 / AACD 24.iso / AACD / Utilities / PdaLink / src / PL_DLP.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-17  |  48.4 KB  |  1,994 lines
  1. /**
  2.  * PdaLink -- Connect Palm with Amiga
  3.  *
  4.  * DLP (Desktop Link Protocol)
  5.  *
  6.  * (C) 1998-2000 Richard Körber <rkoerber@gmx.de>
  7.  *
  8.  *------------------------------------------------------------------
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  *
  24.  * You must not use this source code to gain profit of any kind!
  25.  */
  26.  
  27.  
  28. #include <string.h>
  29. #include "pdalink_glob.h"
  30.  
  31.  
  32. /*------------------------------------------------------**
  33. ** Name:        PL_DLPInit                        public
  34. **
  35. ** Funktion:    Startet eine DLP-Übertragung
  36. **
  37. ** Parameter:   socket    Socket für die Übertragung
  38. //>
  39. ** Bemerkungen:
  40. **
  41. ** Revision:    11. Juni 1998, 23:36:41
  42. */
  43. __saveds __asm void PL_DLPInit
  44. (
  45.   register __a0 APTR socket
  46. )
  47. {
  48.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  49.   sock->dlpoffset = 0;
  50. }
  51. //<
  52. /*------------------------------------------------------**
  53. ** Name:        PL_DLPWriteByte                   public
  54. **
  55. ** Funktion:    Fügt ein Byte zum Paket hinzu
  56. **
  57. ** Parameter:   socket    Socket für die Übertragung
  58. **              byte      Hinzuzufügendes Byte
  59. ** Ergebnis:    length    Aktuelle DLP-Paketlänge
  60. //>
  61. ** Bemerkungen:
  62. **
  63. ** Revision:    11. Juni 1998, 23:36:41
  64. */
  65. __saveds __asm LONG PL_DLPWriteByte
  66. (
  67.   register __a0 APTR socket,
  68.   register __d0 BYTE bdata
  69. )
  70. {
  71.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  72.  
  73.   *(sock->dlpbuffer+(sock->dlpoffset++)+6) = bdata;
  74.   return sock->dlpoffset;
  75. }
  76. //<
  77. /*------------------------------------------------------**
  78. ** Name:        PL_DLPWriteWord                   public
  79. **
  80. ** Funktion:    Fügt ein Word zum Paket hinzu
  81. **
  82. ** Parameter:   socket    Socket für die Übertragung
  83. **              word      Hinzuzufügendes Word
  84. ** Ergebnis:    length    Aktuelle DLP-Paketlänge
  85. //>
  86. ** Bemerkungen:
  87. **
  88. ** Revision:    11. Juni 1998, 23:36:41
  89. */
  90. __saveds __asm LONG PL_DLPWriteWord
  91. (
  92.   register __a0 APTR socket,
  93.   register __d0 WORD wdata
  94. )
  95. {
  96.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  97.  
  98.   *((WORD *)(sock->dlpbuffer+sock->dlpoffset+6)) = wdata;
  99.   sock->dlpoffset += 2;
  100.   return sock->dlpoffset;
  101. }
  102. //<
  103. /*------------------------------------------------------**
  104. ** Name:        PL_DLPWriteLong                   public
  105. **
  106. ** Funktion:    Fügt ein Long zum Paket hinzu
  107. **
  108. ** Parameter:   socket    Socket für die Übertragung
  109. **              long      Hinzuzufügendes Long
  110. ** Ergebnis:    length    Aktuelle DLP-Paketlänge
  111. //>
  112. ** Bemerkungen:
  113. **
  114. ** Revision:    11. Juni 1998, 23:36:41
  115. */
  116. __saveds __asm LONG PL_DLPWriteLong
  117. (
  118.   register __a0 APTR socket,
  119.   register __d0 LONG ldata
  120. )
  121. {
  122.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  123.   *((LONG *)(sock->dlpbuffer+sock->dlpoffset+6)) = ldata;
  124.   sock->dlpoffset += 4;
  125.   return sock->dlpoffset;
  126. }
  127. //<
  128. /*------------------------------------------------------**
  129. ** Name:        PL_DLPWrite                       public
  130. **
  131. ** Funktion:    Fügt Daten zum Paket hinzu
  132. **
  133. ** Parameter:   socket    Socket für die Übertragung
  134. **              packet    Paket
  135. **              length    Länge des Pakets
  136. ** Ergebnis:    length    Aktuelle DLP-Paketlänge
  137. //>
  138. ** Bemerkungen:
  139. **
  140. ** Revision:    11. Juni 1998, 23:36:41
  141. */
  142. __saveds __asm LONG PL_DLPWrite
  143. (
  144.   register __a0 APTR socket,
  145.   register __a1 APTR packet,
  146.   register __d0 LONG length
  147. )
  148. {
  149.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  150.  
  151.   CopyMem(packet,sock->dlpbuffer+sock->dlpoffset+6,length);
  152.   sock->dlpoffset += length;
  153.   return sock->dlpoffset;
  154. }
  155. //<
  156. /*------------------------------------------------------**
  157. ** Name:        PL_DLPTstWrite                    public
  158. **
  159. ** Funktion:    Prüft, ob genug Platz für das Datum
  160. **
  161. ** Parameter:   socket    Socket für die Übertragung
  162. **              length    Länge des Pakets
  163. ** Ergebnis:    success   TRUE: paßt
  164. //>
  165. ** Bemerkungen:
  166. **
  167. ** Revision:    11. Juni 1998, 23:36:41
  168. */
  169. __saveds __asm LONG PL_DLPTstWrite
  170. (
  171.   register __a0 APTR socket,
  172.   register __d0 LONG length
  173. )
  174. {
  175.   return(((struct PL_Socket *)socket)->dlpoffset+6+length <= 0xFFFF);
  176. }
  177. //<
  178. /*------------------------------------------------------**
  179. ** Name:        PL_DLPSend                        public
  180. **
  181. ** Funktion:    Sendet das DLP-Paket ab
  182. **
  183. ** Parameter:   socket    Socket für die Übertragung
  184. **              cmd       Kommando-Code
  185. **              arg       Argument
  186. ** Ergebnis:    length    Länge des Antwortpakets
  187. //>
  188. ** Bemerkungen:
  189. **
  190. ** Revision:    11. Juni 1998, 23:36:41
  191. */
  192. __saveds __asm LONG PL_DLPSend
  193. (
  194.   register __a0 APTR socket,
  195.   register __d0 UBYTE cmd,
  196.   register __d1 UBYTE arg
  197. )
  198. {
  199.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  200.   UBYTE *buf = sock->dlpbuffer;
  201.   LONG msglen = sock->dlpoffset;
  202.   LONG pktlen;
  203.   WORD errcode;
  204.  
  205.   sock->lastError = PLERR_OKAY;
  206.  
  207.   /* collect packet data */
  208.   buf[0] = cmd;
  209.   if(msglen!=0 && arg)
  210.   {
  211.     buf[1] = 1;
  212.     buf[2] = arg|0x80;
  213.     buf[3] = 0;
  214.     buf[4] = msglen>>8;
  215.     buf[5] = msglen&0xFF;
  216.     pktlen = msglen+6;
  217.   }
  218.   else
  219.   {
  220.     buf[1] = 0;
  221.     pktlen = 2;
  222.   }
  223.  
  224.   /* send DLP packet */
  225.   if(PL_Write(socket,buf,pktlen) != pktlen)
  226.   {
  227.     return -1;
  228.   }
  229.  
  230.   /* Wait for reply */
  231.   pktlen = PL_Read(socket,buf,65536);
  232.   if(pktlen==-1) return -1;
  233.  
  234.   /* DLP error occured? */
  235.   errcode = buf[2]<<8 | buf[3];
  236.   if(errcode)
  237.   {
  238.     sock->lastError = errcode;
  239.     return -1;
  240.   }
  241.  
  242.   /* Got right packet? */
  243.   if(buf[0] != (cmd|0x80))
  244.   {
  245.     sock->lastError = PLERR_BADPACKET;
  246.     return -1;
  247.   }
  248.  
  249.   /* Collect answer */
  250.   sock->dlpoffset = 0;                          // Read from the beginning
  251.   if(!buf[1])                                   // No answer expected
  252.   {
  253.     sock->readoffset = 0;
  254.     return 0;
  255.   }
  256.  
  257.   if((buf[4]&0xC0) == 0xC0)                     // Long
  258.   {
  259.     pktlen = ((((((buf[6]<<8) | buf[7])<<8) | buf[8])<<8) | buf[9]);
  260.     sock->readoffset = 10;
  261.   }
  262.   else if((buf[4]&0xC0) == 0x80)                // Short
  263.   {
  264.     pktlen = (buf[6]<<8) | buf[7];
  265.     sock->readoffset = 8;
  266.   }
  267.   else                                          // Tiny
  268.   {
  269.     pktlen = buf[5];
  270.     sock->readoffset = 6;
  271.   }
  272.  
  273.   return pktlen;
  274. }
  275. //<
  276. /*------------------------------------------------------**
  277. ** Name:        PL_DLPRead                        public
  278. **
  279. ** Funktion:    Liest Daten aus dem Paket
  280. **
  281. ** Parameter:   socket    Socket für die Übertragung
  282. **              buffer    Pufferspeicher (NULL:Skip)
  283. **              length    Länge des Puffers
  284. ** Ergebnis:    momentan stets = length
  285. //>
  286. ** Bemerkungen:
  287. **
  288. ** Revision:    11. Juni 1998, 23:53:33
  289. */
  290. __saveds __asm LONG PL_DLPRead
  291. (
  292.   register __a0 APTR socket,
  293.   register __a1 APTR buffer,
  294.   register __d0 LONG length
  295. )
  296. {
  297.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  298.  
  299.   if(buffer)
  300.     CopyMem(sock->dlpbuffer+sock->readoffset+sock->dlpoffset , buffer, length);
  301.   sock->dlpoffset += length;
  302.   return length;
  303. }
  304. //<
  305.  
  306.  
  307.  
  308.  
  309.  
  310. /*------------------------------------------------------**
  311. ** Name:        DLP_OpenConduit                   public
  312. **
  313. ** Funktion:    Startet die Verbindung
  314. **
  315. ** Parameter:   socket    Socket für die Übertragung
  316. ** Ergebnis:    success
  317. //>
  318. ** Bemerkungen:
  319. **
  320. ** Revision:     9. Juni 1998, 22:06:58
  321. */
  322. __saveds __asm int DLP_OpenConduit
  323. (
  324.   register __a0 APTR socket
  325. )
  326. {
  327.   PL_DLPInit(socket);
  328.   return(PL_DLPSend(socket,0x2E,0x00) != -1);
  329. }
  330. //<
  331. /*------------------------------------------------------**
  332. ** Name:        DLP_EndOfSync                     public
  333. **
  334. ** Funktion:    Beendet die Verbindung
  335. **
  336. ** Parameter:   socket    Socket für die Übertragung
  337. **              status    Status-Code
  338. ** Ergebnis:    success
  339. //>
  340. ** Bemerkungen:
  341. **
  342. ** Revision:     9. Juni 1998, 22:06:58
  343. */
  344. __saveds __asm int DLP_EndOfSync
  345. (
  346.   register __a0 APTR socket,
  347.   register __d0 UWORD status
  348. )
  349. {
  350.   PL_DLPInit(socket);
  351.   PL_DLPWriteWord(socket,(WORD)status);
  352.   return(PL_DLPSend(socket,0x2F,0x20) != -1);
  353. }
  354. //<
  355.  
  356. /*------------------------------------------------------**
  357. ** Name:        DLP_SetSysTime                    public
  358. **
  359. ** Funktion:    Setzt die Systemzeit des Palm
  360. **
  361. ** Parameter:   socket    Socket für die Übertragung
  362. **              time      Time-Struct
  363. ** Ergebnis:    success
  364. //>
  365. ** Bemerkungen:
  366. **
  367. ** Revision:     9. Juni 1998, 22:06:58
  368. */
  369. __saveds __asm int DLP_SetSysTime
  370. (
  371.   register __a0 APTR socket,
  372.   register __a1 struct DLP_SysTime *time
  373. )
  374. {
  375.   PL_DLPInit(socket);
  376.   PL_DLPWrite(socket,time,sizeof(struct DLP_SysTime));
  377.   return(PL_DLPSend(socket,0x14,0x20) != -1);
  378. }
  379. //<
  380. /*------------------------------------------------------**
  381. ** Name:        DLP_GetSysTime                    public
  382. **
  383. ** Funktion:    Liest die Systemzeit des Palm
  384. **
  385. ** Parameter:   socket    Socket für die Übertragung
  386. **              time      Time-Struct
  387. ** Ergebnis:    success
  388. //>
  389. ** Bemerkungen:
  390. **
  391. ** Revision:     9. Juni 1998, 22:06:58
  392. */
  393. __saveds __asm int DLP_GetSysTime
  394. (
  395.   register __a0 APTR socket,
  396.   register __a1 struct DLP_SysTime *time
  397. )
  398. {
  399.   PL_DLPInit(socket);
  400.   if(PL_DLPSend(socket,0x13,0x20) == -1) return(FALSE);
  401.   PL_DLPRead(socket,time,sizeof(struct DLP_SysTime));
  402.   return(TRUE);
  403. }
  404. //<
  405.  
  406. /*------------------------------------------------------**
  407. ** Name:        DLP_GetStorageInfo                public
  408. **
  409. ** Funktion:    Liest Infos über den Palm-Speicher
  410. **
  411. ** Parameter:   socket    Socket für die Übertragung
  412. **              cardno    Karten-Nummer
  413. **              info      Platz für Informationen darüber
  414. ** Ergebnis:    success
  415. //>
  416. ** Bemerkungen:
  417. **
  418. ** Revision:     9. Juni 1998, 22:06:58
  419. */
  420. __saveds __asm int DLP_GetStorageInfo
  421. (
  422.   register __a0 APTR socket,
  423.   register __d0 UBYTE cardno,
  424.   register __a1 struct DLP_StorageInfo *info
  425. )
  426. {
  427.   struct DLP_SIResult
  428.   {
  429.     UBYTE number;
  430.     UBYTE more;
  431.     UBYTE pad;
  432.     UBYTE count;
  433.     UBYTE totalSize;
  434.     UBYTE cardNo;
  435.     UWORD cardVersion;
  436.     struct DLP_SysTime date;
  437.     ULONG ROMSize;
  438.     ULONG RAMSize;
  439.     ULONG RAMFree;
  440.     UBYTE cardNameSize;
  441.     UBYTE cardManufSize;
  442.     UBYTE NameManufBuffer[256];
  443.   }
  444.   sres;
  445.  
  446.   PL_DLPInit(socket);
  447.   PL_DLPWriteByte(socket,(BYTE)cardno);
  448.   PL_DLPWriteByte(socket,0);
  449.  
  450.   if(PL_DLPSend(socket,0x15,0x20) == -1) return(FALSE);
  451.  
  452.   PL_DLPRead(socket,&sres,sizeof(struct DLP_SIResult));
  453.   info->more        = (sres.count>1 || sres.more);
  454.   info->cardNo      = sres.cardNo;
  455.   info->cardVersion = sres.cardVersion;
  456.   info->date        = sres.date;
  457.   info->ROMSize     = sres.ROMSize;
  458.   info->RAMSize     = sres.RAMSize;
  459.   info->RAMFree     = sres.RAMFree;
  460.   CopyMem(sres.NameManufBuffer, info->name, sres.cardNameSize);
  461.   info->name[sres.cardNameSize] = '\0';
  462.   CopyMem(sres.NameManufBuffer+sres.cardNameSize,info->manuf,sres.cardManufSize);
  463.   info->manuf[sres.cardManufSize] = '\0';
  464.  
  465.   return(TRUE);
  466. }
  467. //<
  468.  
  469. /*------------------------------------------------------**
  470. ** Name:        DLP_GetSysInfo                    public
  471. **
  472. ** Funktion:    Liest Infos über das System
  473. **
  474. ** Parameter:   socket    Socket für die Übertragung
  475. **              info      Speicher für SysInfo
  476. ** Ergebnis:    success
  477. //>
  478. ** Bemerkungen:
  479. **
  480. ** Revision:     9. Juni 1998, 22:06:58
  481. */
  482. __saveds __asm int DLP_GetSysInfo
  483. (
  484.   register __a0 APTR socket,
  485.   register __a1 struct DLP_SysInfo *info
  486. )
  487. {
  488.   UBYTE len;
  489.  
  490.   PL_DLPInit(socket);
  491.   if(PL_DLPSend(socket,0x12,0x20) == -1) return(FALSE);
  492.  
  493.   PL_DLPRead(socket,&info->romVer,4);   // ULONG        (0)   romVer
  494.   PL_DLPRead(socket,&info->locale,4);   // ULONG        (4)   locale
  495.   PL_DLPRead(socket,NULL,1);            // UBYTE        (8)   pad
  496.   PL_DLPRead(socket,&len,1);            // UBYTE        (9)   NameLen
  497.   PL_DLPRead(socket,info->name,len);    // UBYTE[128]   (10)  Name
  498.   info->name[len] = '\0';
  499.  
  500.   return(TRUE);
  501. }
  502. //<
  503.  
  504. /*------------------------------------------------------**
  505. ** Name:        DLP_GetDBInfo                     public
  506. **
  507. ** Funktion:    Liest Infos über die Datenbank
  508. **
  509. ** Parameter:   socket    Socket für die Übertragung
  510. **              cardno    Karten-Nummer
  511. **              flags     Flags
  512. **              start     Erste Eintrags-Nummer
  513. **              info      Speicher für DBInfo
  514. ** Ergebnis:    success
  515. //>
  516. ** Bemerkungen:
  517. **
  518. ** Revision:     9. Juni 1998, 22:06:58
  519. */
  520. __saveds __asm int DLP_GetDBInfo
  521. (
  522.   register __a0 APTR socket,
  523.   register __d0 UBYTE cardno,
  524.   register __d1 UBYTE flags,
  525.   register __d2 UWORD start,
  526.   register __a1 struct DLP_DBInfo *info
  527. )
  528. {
  529.   PL_DLPInit(socket);
  530.   PL_DLPWriteByte(socket,(BYTE)flags);
  531.   PL_DLPWriteByte(socket,(BYTE)cardno);
  532.   PL_DLPWriteWord(socket,(WORD)start);
  533.  
  534.   if(PL_DLPSend(socket,0x16,0x20) == -1) return(FALSE);
  535.  
  536.   PL_DLPRead(socket,NULL                ,2);
  537.   PL_DLPRead(socket,&info->more         ,1);
  538.   PL_DLPRead(socket,NULL                ,2);
  539.   PL_DLPRead(socket,&info->excludes     ,1);
  540.   PL_DLPRead(socket,&info->flags        ,2);
  541.   PL_DLPRead(socket,&info->type         ,4);
  542.   PL_DLPRead(socket,&info->creator      ,4);
  543.   PL_DLPRead(socket,&info->version      ,2);
  544.   PL_DLPRead(socket,&info->modnum       ,4);
  545.   PL_DLPRead(socket,&info->createDate   ,sizeof(struct DLP_SysTime));
  546.   PL_DLPRead(socket,&info->modifyDate   ,sizeof(struct DLP_SysTime));
  547.   PL_DLPRead(socket,&info->backupDate   ,sizeof(struct DLP_SysTime));
  548.   PL_DLPRead(socket,&info->index        ,2);
  549.   PL_DLPRead(socket,&info->name         ,32);
  550.   info->name[32] = '\0';
  551.  
  552.   return(TRUE);
  553. }
  554. //<
  555.  
  556. /*------------------------------------------------------**
  557. ** Name:        DLP_OpenDB                        public
  558. **
  559. ** Funktion:    Öffnet eine Datenbank
  560. **
  561. ** Parameter:   socket    Socket für die Übertragung
  562. **              cardno    Karten-Nummer
  563. **              mode      Modus
  564. **              name      Name
  565. ** Ergebnis:    handle    DB-Handle oder -1:Error
  566. //>
  567. ** Bemerkungen:
  568. **
  569. ** Revision:     9. Juni 1998, 22:06:58
  570. */
  571. __saveds __asm LONG DLP_OpenDB
  572. (
  573.   register __a0 APTR socket,
  574.   register __d0 UBYTE cardno,
  575.   register __d1 UBYTE mode,
  576.   register __a1 STRPTR name
  577. )
  578. {
  579.   UBYTE handle;
  580.  
  581.   PL_DLPInit(socket);
  582.   PL_DLPWriteByte(socket,(BYTE)cardno);
  583.   PL_DLPWriteByte(socket,(BYTE)mode);
  584.   PL_DLPWrite(socket,name,strlen(name)+1);
  585.  
  586.   if(PL_DLPSend(socket,0x17,0x20) == -1) return(-1);
  587.  
  588.   PL_DLPRead(socket,&handle,1);
  589.   return(handle);
  590. }
  591. //<
  592.  
  593. /*------------------------------------------------------**
  594. ** Name:        DLP_DeleteDB                      public
  595. **
  596. ** Funktion:    Löscht eine Datenbank
  597. **
  598. ** Parameter:   socket    Socket für die Übertragung
  599. **              cardno    Karten-Nummer
  600. **              name      Name
  601. ** Ergebnis:    success
  602. //>
  603. ** Bemerkungen:
  604. **
  605. ** Revision:     9. Juni 1998, 22:06:58
  606. */
  607. __saveds __asm int DLP_DeleteDB
  608. (
  609.   register __a0 APTR socket,
  610.   register __d0 UBYTE cardno,
  611.   register __a1 STRPTR name
  612. )
  613. {
  614.   PL_DLPInit(socket);
  615.   PL_DLPWriteByte(socket,(BYTE)cardno);
  616.   PL_DLPWriteByte(socket,0);
  617.   PL_DLPWrite(socket,name,strlen(name)+1);
  618.   return(PL_DLPSend(socket,0x1A,0x20) != -1);
  619. }
  620. //<
  621.  
  622. /*------------------------------------------------------**
  623. ** Name:        DLP_CreateDB                      public
  624. **
  625. ** Funktion:    Erstellt eine Datenbank
  626. **
  627. ** Parameter:   socket    Socket für die Übertragung
  628. **              cardno    Karten-Nummer
  629. **              creator   Erzeuger-ID
  630. **              type      Typ-ID
  631. **              flags     Flags
  632. **              version   Versionsnr.
  633. **              name      Name
  634. ** Ergebnis:    handle    DB-Handle oder -1:Error
  635. //>
  636. ** Bemerkungen:
  637. **
  638. ** Revision:    12. Juni 1998, 00:28:28
  639. */
  640. __saveds __asm LONG DLP_CreateDB
  641. (
  642.   register __a0 APTR socket,
  643.   register __d0 UBYTE cardno,
  644.   register __d1 ULONG creator,
  645.   register __d2 ULONG type,
  646.   register __d3 UWORD flags,
  647.   register __d4 UWORD version,
  648.   register __a1 STRPTR name
  649. )
  650. {
  651.   UBYTE handle;
  652.  
  653.   PL_DLPInit(socket);
  654.   PL_DLPWriteLong(socket,(LONG)creator);
  655.   PL_DLPWriteLong(socket,(LONG)type);
  656.   PL_DLPWriteByte(socket,(BYTE)cardno);
  657.   PL_DLPWriteByte(socket,0);
  658.   PL_DLPWriteWord(socket,(WORD)flags);
  659.   PL_DLPWriteWord(socket,(WORD)version);
  660.   PL_DLPWrite(socket,name,strlen(name)+1);
  661.   if(PL_DLPSend(socket,0x18,0x20) == -1) return(-1);
  662.   PL_DLPRead(socket,&handle,1);
  663.   return(handle);
  664. }
  665. //<
  666.  
  667. /*------------------------------------------------------**
  668. ** Name:        DLP_CloseDB                       public
  669. **
  670. ** Funktion:    Schließt eine Datenbank
  671. **
  672. ** Parameter:   socket    Socket für die Übertragung
  673. **              handle    DB-Handle
  674. ** Ergebnis:    success
  675. //>
  676. ** Bemerkungen:
  677. **
  678. ** Revision:     9. Juni 1998, 22:06:58
  679. */
  680. __saveds __asm int DLP_CloseDB
  681. (
  682.   register __a0 APTR socket,
  683.   register __d0 LONG handle
  684. )
  685. {
  686.   PL_DLPInit(socket);
  687.   PL_DLPWriteByte(socket,(BYTE)handle);
  688.   return(PL_DLPSend(socket,0x19,0x20) != -1);
  689. }
  690. //<
  691.  
  692. /*------------------------------------------------------**
  693. ** Name:        DLP_CloseAllDB                    public
  694. **
  695. ** Funktion:    Schließt alle Datenbanken
  696. **
  697. ** Parameter:   socket    Socket für die Übertragung
  698. ** Ergebnis:    success
  699. //>
  700. ** Bemerkungen:
  701. **
  702. ** Revision:     9. Juni 1998, 22:06:58
  703. */
  704. __saveds __asm int DLP_CloseAllDB
  705. (
  706.   register __a0 APTR socket
  707. )
  708. {
  709.   PL_DLPInit(socket);
  710.   return(PL_DLPSend(socket,0x19,0x21) != -1);
  711. }
  712. //<
  713.  
  714. /*------------------------------------------------------**
  715. ** Name:        DLP_ResetSystem                   public
  716. **
  717. ** Funktion:    Setzt den Palm zurück
  718. **
  719. ** Parameter:   socket    Socket für die Übertragung
  720. ** Ergebnis:    success
  721. //>
  722. ** Bemerkungen:
  723. **
  724. ** Revision:     9. Juni 1998, 22:06:58
  725. */
  726. __saveds __asm int DLP_ResetSystem
  727. (
  728.   register __a0 APTR socket
  729. )
  730. {
  731.   PL_DLPInit(socket);
  732.   return(PL_DLPSend(socket,0x29,0x00) != -1);
  733. }
  734. //<
  735.  
  736. /*------------------------------------------------------**
  737. ** Name:        DLP_AddSyncLogEntry
  738. **
  739. ** Funktion:    Eintrag in die Sync-Datenbank
  740. **
  741. ** Parameter:   socket    Socket für die Übertragung
  742. **              entry     Eintrag
  743. ** Ergebnis:    success
  744. //>
  745. ** Bemerkungen:
  746. **
  747. ** Revision:    12. Juni 1998, 22:27:34
  748. */
  749. __saveds __asm int DLP_AddSyncLogEntry
  750. (
  751.   register __a0 APTR socket,
  752.   register __a1 STRPTR entry
  753. )
  754. {
  755.   PL_DLPInit(socket);
  756.   PL_DLPWrite(socket,entry,strlen(entry)+1);
  757.   return(PL_DLPSend(socket,0x2A,0x20) != -1);
  758. }
  759. //<
  760.  
  761. /*------------------------------------------------------**
  762. ** Name:        DLP_CountDBEntries
  763. **
  764. ** Funktion:    Ermittelt die Anzahl der Einträge
  765. **
  766. ** Parameter:   socket    Socket für die Übertragung
  767. **              handle    Handle
  768. ** Ergebnis:    entries
  769. //>
  770. ** Bemerkungen:
  771. **
  772. ** Revision:    12. Juni 1998, 22:36:34
  773. */
  774. __saveds __asm LONG DLP_CountDBEntries
  775. (
  776.   register __a0 APTR socket,
  777.   register __d0 LONG handle
  778. )
  779. {
  780.   UWORD entr;
  781.  
  782.   PL_DLPInit(socket);
  783.   PL_DLPWriteByte(socket,(BYTE)handle);
  784.   if(PL_DLPSend(socket,0x2B,0x20) == -1) return(-1);
  785.   PL_DLPRead(socket,&entr,sizeof(UWORD));
  786.   return((LONG)entr);
  787. }
  788. //<
  789.  
  790. /*------------------------------------------------------**
  791. ** Name:        DLP_MoveCategory
  792. **
  793. ** Funktion:    Verschiebt eine Kategorie
  794. **
  795. ** Parameter:   socket    Socket für die Übertragung
  796. **              handle    Handle
  797. **              oldcat    alte Kategorie
  798. **              newcat    neue Kategorie
  799. ** Ergebnis:    success
  800. //>
  801. ** Bemerkungen:
  802. **
  803. ** Revision:    12. Juni 1998, 22:42:34
  804. */
  805. __saveds __asm int DLP_MoveCategory
  806. (
  807.   register __a0 APTR socket,
  808.   register __d0 LONG handle,
  809.   register __d1 UBYTE oldcat,
  810.   register __d2 UBYTE newcat
  811. )
  812. {
  813.   PL_DLPInit(socket);
  814.   PL_DLPWriteByte(socket,(BYTE)handle);
  815.   PL_DLPWriteByte(socket,(BYTE)oldcat);
  816.   PL_DLPWriteByte(socket,(BYTE)newcat);
  817.   PL_DLPWriteByte(socket,0);
  818.   return(PL_DLPSend(socket,0x2C,0x20) != -1);
  819. }
  820. //<
  821.  
  822. /*------------------------------------------------------**
  823. ** Name:        DLP_SetUserInfo
  824. **
  825. ** Funktion:    Schreibt eine Userinfo
  826. **
  827. ** Parameter:   socket    Socket für die Übertragung
  828. **              user      Userinfo
  829. ** Ergebnis:    success
  830. //>
  831. ** Bemerkungen:
  832. **
  833. ** Revision:    12. Juni 1998, 22:47:04
  834. */
  835. __saveds __asm int DLP_SetUserInfo
  836. (
  837.   register __a0 APTR socket,
  838.   register __a1 struct DLP_UserInfo *user
  839. )
  840. {
  841.   PL_DLPInit(socket);
  842.   PL_DLPWriteLong(socket,(LONG)user->userID);
  843.   PL_DLPWriteLong(socket,(LONG)user->viewerID);
  844.   PL_DLPWriteLong(socket,(LONG)user->lastSyncPC);
  845.   PL_DLPWrite(socket,&user->successfulSync,sizeof(struct DLP_SysTime));
  846.   PL_DLPWriteByte(socket,(BYTE)0xFF);
  847.   PL_DLPWriteByte(socket,strlen(user->userName)+1);
  848.   PL_DLPWrite(socket,user->userName,strlen(user->userName)+1);
  849.   return(PL_DLPSend(socket,0x11,0x20) != -1);
  850. }
  851. //<
  852. /*------------------------------------------------------**
  853. ** Name:        DLP_GetUserInfo
  854. **
  855. ** Funktion:    Liest eine Userinfo
  856. **
  857. ** Parameter:   socket    Socket für die Übertragung
  858. **              user      Userinfo
  859. ** Ergebnis:    success
  860. //>
  861. ** Bemerkungen:
  862. **
  863. ** Revision:    12. Juni 1998, 22:47:04
  864. */
  865. __saveds __asm int DLP_GetUserInfo
  866. (
  867.   register __a0 APTR socket,
  868.   register __a1 struct DLP_UserInfo *user
  869. )
  870. {
  871.   UBYTE userlen;
  872.   UBYTE pwlen;
  873.  
  874.   PL_DLPInit(socket);
  875.   if(PL_DLPSend(socket,0x10,0x00) == -1) return(FALSE);
  876.   PL_DLPRead(socket,&user->userID,4);
  877.   PL_DLPRead(socket,&user->viewerID,4);
  878.   PL_DLPRead(socket,&user->lastSyncPC,4);
  879.   PL_DLPRead(socket,&user->successfulSync,sizeof(struct DLP_SysTime));
  880.   PL_DLPRead(socket,&user->lastSync,sizeof(struct DLP_SysTime));
  881.   PL_DLPRead(socket,&userlen,1);
  882.   PL_DLPRead(socket,&pwlen,1);
  883.   PL_DLPRead(socket,user->userName,userlen);
  884.   user->userName[userlen] = '\0';
  885.   PL_DLPRead(socket,user->password,pwlen);
  886.   user->password[pwlen] = '\0';
  887.   return(TRUE);
  888. }
  889. //<
  890.  
  891. /*------------------------------------------------------**
  892. ** Name:        DLP_SetNetSyncInfo
  893. **
  894. ** Funktion:    Schreibt eine NetSyncInfo
  895. **
  896. ** Parameter:   socket    Socket für die Übertragung
  897. **              netsync   NetSync-Info
  898. ** Ergebnis:    success
  899. //>
  900. ** Bemerkungen:
  901. **
  902. ** Revision:    12. Juni 1998, 23:42:44
  903. */
  904. __saveds __asm int DLP_SetNetSyncInfo
  905. (
  906.   register __a0 APTR socket,
  907.   register __a1 struct DLP_NetSyncInfo *netsync
  908. )
  909. {
  910.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  911.  
  912.   if(sock->version < 0x0101)
  913.   {
  914.     sock->lastError = PLERR_OS2REQUIRED;
  915.     return(FALSE);
  916.   }
  917.  
  918.   PL_DLPInit(socket);
  919.   PL_DLPWriteByte(socket,(BYTE)0x80|0x40|0x20|0x10);  // Change all Settings
  920.   PL_DLPWriteByte(socket,netsync->lanSync);
  921.   PL_DLPWriteLong(socket,0);
  922.   PL_DLPWriteLong(socket,0);
  923.   PL_DLPWriteLong(socket,0);
  924.   PL_DLPWriteLong(socket,0);
  925.   PL_DLPWriteWord(socket,strlen(netsync->hostName)+1);
  926.   PL_DLPWriteWord(socket,strlen(netsync->hostAddress)+1);
  927.   PL_DLPWriteWord(socket,strlen(netsync->hostSubnetMask)+1);
  928.   PL_DLPWrite(socket,netsync->hostName,strlen(netsync->hostName)+1);
  929.   PL_DLPWrite(socket,netsync->hostAddress,strlen(netsync->hostAddress)+1);
  930.   PL_DLPWrite(socket,netsync->hostSubnetMask,strlen(netsync->hostSubnetMask)+1);
  931.  
  932.   return(PL_DLPSend(socket,0x37,0x20) != -1);
  933. }
  934. //<
  935. /*------------------------------------------------------**
  936. ** Name:        DLP_GetNetSyncInfo
  937. **
  938. ** Funktion:    Liest eine NetSyncInfo
  939. **
  940. ** Parameter:   socket    Socket für die Übertragung
  941. **              netsync   NetSync-Info
  942. ** Ergebnis:    success
  943. //>
  944. ** Bemerkungen:
  945. **
  946. ** Revision:    12. Juni 1998, 23:22:47
  947. */
  948. __saveds __asm int DLP_GetNetSyncInfo
  949. (
  950.   register __a0 APTR socket,
  951.   register __a1 struct DLP_NetSyncInfo *netsync
  952. )
  953. {
  954.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  955.   UWORD hnamelen;
  956.   UWORD haddresslen;
  957.   UWORD submasklen;
  958.  
  959.   if(sock->version < 0x0101)
  960.   {
  961.     sock->lastError = PLERR_OS2REQUIRED;
  962.     return(FALSE);
  963.   }
  964.  
  965.   PL_DLPInit(socket);
  966.   if(PL_DLPSend(socket,0x36,0x20) == -1) return(FALSE);
  967.   PL_DLPRead(socket,&netsync->lanSync,1);
  968.   PL_DLPRead(socket,NULL,17);
  969.   PL_DLPRead(socket,&hnamelen,2);
  970.   PL_DLPRead(socket,&haddresslen,2);
  971.   PL_DLPRead(socket,&submasklen,2);
  972.   PL_DLPRead(socket,netsync->hostName,hnamelen);
  973.   netsync->hostName[hnamelen] = '\0';
  974.   PL_DLPRead(socket,netsync->hostAddress,haddresslen);
  975.   netsync->hostAddress[haddresslen] = '\0';
  976.   PL_DLPRead(socket,netsync->hostSubnetMask,submasklen);
  977.   netsync->hostSubnetMask[submasklen] = '\0';
  978.   return(TRUE);
  979. }
  980. //<
  981.  
  982. /*------------------------------------------------------**
  983. ** Name:        DLP_ResetLastSyncPC
  984. **
  985. ** Funktion:    Liest eine NetSyncInfo
  986. **
  987. ** Parameter:   socket    Socket für die Übertragung
  988. ** Ergebnis:    success
  989. //>
  990. ** Bemerkungen:
  991. **
  992. ** Revision:    12. Juni 1998, 23:22:47
  993. */
  994. __saveds __asm int DLP_ResetLastSyncPC
  995. (
  996.   register __a0 APTR socket
  997. )
  998. {
  999.   struct DLP_UserInfo user;
  1000.  
  1001.   if(!DLP_GetUserInfo(socket,&user)) return(FALSE);
  1002.   user.lastSyncPC = 0;
  1003.   return(DLP_SetUserInfo(socket,&user));
  1004. }
  1005. //<
  1006.  
  1007. /*------------------------------------------------------**
  1008. ** Name:        DLP_ResetDBIndex
  1009. **
  1010. ** Funktion:    Liest eine NetSyncInfo
  1011. **
  1012. ** Parameter:   socket    Socket für die Übertragung
  1013. **              handle    DBHandle
  1014. ** Ergebnis:    success
  1015. //>
  1016. ** Bemerkungen:
  1017. **
  1018. ** Revision:    12. Juni 1998, 23:22:47
  1019. */
  1020. __saveds __asm int DLP_ResetDBIndex
  1021. (
  1022.   register __a0 APTR socket,
  1023.   register __d0 LONG handle
  1024. )
  1025. {
  1026.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1027.  
  1028.   sock->dlprecord = 0;
  1029.   PL_DLPInit(socket);
  1030.   PL_DLPWriteByte(socket,(BYTE)handle);
  1031.   return(PL_DLPSend(socket,0x30,0x20) != -1);
  1032. }
  1033. //<
  1034.  
  1035. /*------------------------------------------------------**
  1036. ** Name:        DLP_GetRecordIDList
  1037. **
  1038. ** Funktion:    Liest eine Liste von Records-IDs
  1039. **
  1040. ** Parameter:   socket    Socket für die Übertragung
  1041. **              handle    DBHandle
  1042. **              sort      Sortieren?
  1043. **              start     Start-ID
  1044. **              max       Platz in Structure
  1045. **              ids       Table für IDs
  1046. **              count     Zählvariable
  1047. ** Ergebnis:    success
  1048. //>
  1049. ** Bemerkungen:
  1050. **
  1051. ** Revision:    13. Juni 1998, 00:22:59
  1052. */
  1053. __saveds __asm LONG DLP_GetRecordIDList
  1054. (
  1055.   register __a0 APTR socket,
  1056.   register __d0 LONG handle,
  1057.   register __d1 BOOL sort,
  1058.   register __d2 UWORD start,
  1059.   register __d3 UWORD max,
  1060.   register __a1 ULONG *ids
  1061. )
  1062. {
  1063.   LONG retnum;
  1064.   UWORD num;
  1065.  
  1066.   PL_DLPInit(socket);
  1067.   PL_DLPWriteByte(socket,(BYTE)handle);
  1068.   PL_DLPWriteByte(socket,(sort ? 0x80 : 0x00));
  1069.   PL_DLPWriteWord(socket,start);
  1070.   PL_DLPWriteWord(socket,max);
  1071.   if(PL_DLPSend(socket,0x31,0x20) == -1) return(-1);
  1072.   PL_DLPRead(socket,&num,2);
  1073.   retnum = num;
  1074.   while(num--) PL_DLPRead(socket,ids++,4);
  1075.   return(retnum);
  1076. }
  1077. //<
  1078.  
  1079. /*------------------------------------------------------**
  1080. ** Name:        DLP_WriteRecord
  1081. **
  1082. ** Funktion:    Schreibt einen Record
  1083. **
  1084. ** Parameter:   socket    Socket für die Übertragung
  1085. **              handle    DBHandle
  1086. **              flags     Flags
  1087. **              id        Record-ID
  1088. **              catid     Kategorie-ID
  1089. **              buffer    Pufferdaten
  1090. **              length    Länge des Puffers
  1091. **              newid     rückgelieferte ID
  1092. ** Ergebnis:    success
  1093. //>
  1094. ** Bemerkungen:
  1095. **
  1096. ** Revision:    13. Juni 1998, 00:34:13
  1097. */
  1098. __saveds __asm int DLP_WriteRecord
  1099. (
  1100.   register __a0 APTR socket,
  1101.   register __d0 LONG handle,
  1102.   register __d1 UBYTE flags,
  1103.   register __d2 ULONG id,
  1104.   register __d3 UBYTE catid,
  1105.   register __a1 APTR buffer,
  1106.   register __d4 UWORD length,
  1107.   register __a2 ULONG *newid
  1108. )
  1109. {
  1110.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1111.   LONG reply;
  1112.  
  1113.   PL_DLPInit(socket);
  1114.   PL_DLPWriteByte(socket,(BYTE)handle);
  1115.   PL_DLPWriteByte(socket,0);
  1116.   PL_DLPWriteLong(socket,(LONG)id);
  1117.   PL_DLPWriteByte(socket,(BYTE)flags);
  1118.   PL_DLPWriteByte(socket,(BYTE)catid);
  1119.   if(!PL_DLPTstWrite(socket,length))
  1120.   {
  1121.     sock->lastError = PLERR_TOOLARGE;
  1122.     return(FALSE);
  1123.   }
  1124.   PL_DLPWrite(socket,buffer,length);
  1125.  
  1126.   if((reply=PL_DLPSend(socket,0x21,0x20)) == -1) return(FALSE);
  1127.  
  1128.   if(newid)
  1129.   {
  1130.     if(reply==4)
  1131.       PL_DLPRead(socket,newid,4);
  1132.     else
  1133.       *newid = 0;
  1134.   }
  1135.  
  1136.   return(TRUE);
  1137. }
  1138. //<
  1139.  
  1140. /*------------------------------------------------------**
  1141. ** Name:        DLP_DeleteRecord
  1142. **
  1143. ** Funktion:    Löscht einen Record
  1144. **
  1145. ** Parameter:   socket    Socket für die Übertragung
  1146. **              handle    DBHandle
  1147. **              all       Alle Records
  1148. **              id        Record-ID
  1149. ** Ergebnis:    success
  1150. //>
  1151. ** Bemerkungen:
  1152. **
  1153. ** Revision:    13. Juni 1998, 00:43:18
  1154. */
  1155. __saveds __asm int DLP_DeleteRecord
  1156. (
  1157.   register __a0 APTR socket,
  1158.   register __d0 LONG handle,
  1159.   register __d1 BOOL all,
  1160.   register __d2 ULONG id
  1161. )
  1162. {
  1163.   PL_DLPInit(socket);
  1164.   PL_DLPWriteByte(socket,(BYTE)handle);
  1165.   PL_DLPWriteByte(socket,(all ? 0x80 : 0x00));
  1166.   PL_DLPWriteLong(socket,(LONG)id);
  1167.   return(PL_DLPSend(socket,0x22,0x20) != -1);
  1168. }
  1169. //<
  1170.  
  1171. /*------------------------------------------------------**
  1172. ** Name:        DLP_DeleteCategory
  1173. **
  1174. ** Funktion:    Löscht eine Kategorie
  1175. **
  1176. ** Parameter:   socket    Socket für die Übertragung
  1177. **              handle    DBHandle
  1178. **              category  Kategorie-Code
  1179. ** Ergebnis:    success
  1180. //>
  1181. ** Bemerkungen:
  1182. **
  1183. ** Revision:    13. Juni 1998, 00:43:18
  1184. */
  1185. __saveds __asm int DLP_DeleteCategory
  1186. (
  1187.   register __a0 APTR socket,
  1188.   register __d0 LONG handle,
  1189.   register __d1 UBYTE category
  1190. )
  1191. {
  1192.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1193.  
  1194.   if(sock->version < 0x0101)
  1195.   {
  1196.     /*TODO: write PalmOS 1 emulation code */
  1197.     sock->lastError = PLERR_OS2REQUIRED;
  1198.     return(FALSE);
  1199.   }
  1200.  
  1201.   PL_DLPInit(socket);
  1202.   PL_DLPWriteByte(socket,(BYTE)handle);
  1203.   PL_DLPWriteByte(socket,0x40);
  1204.   PL_DLPWriteLong(socket,((LONG)category) & 0xFF);
  1205.   return(PL_DLPSend(socket,0x22,0x20) != -1);
  1206. }
  1207. //<
  1208.  
  1209. /*------------------------------------------------------**
  1210. ** Name:        DLP_ReadResourceByType
  1211. **
  1212. ** Funktion:    Liest eine Resource nach Typ
  1213. **
  1214. ** Parameter:   socket    Socket für die Übertragung
  1215. **              handle    DBHandle
  1216. **              type      Typ-ID
  1217. **              id        Kategorie-ID
  1218. **              buffer    Zielpuffer
  1219. **              index
  1220. **              size
  1221. ** Ergebnis:    length    Datenpaket
  1222. //>
  1223. ** Bemerkungen:
  1224. **
  1225. ** Revision:    13. Juni 1998, 00:52:51
  1226. */
  1227. __saveds __asm LONG DLP_ReadResourceByType
  1228. (
  1229.   register __a0 APTR socket,
  1230.   register __d0 LONG handle,
  1231.   register __d1 ULONG type,
  1232.   register __d2 UWORD id,
  1233.   register __a1 APTR buffer,
  1234.   register __a2 UWORD *index,
  1235.   register __a3 UWORD *size
  1236. )
  1237. {
  1238.   LONG reply;
  1239.  
  1240.   PL_DLPInit(socket);
  1241.   PL_DLPWriteByte(socket,(BYTE)handle);
  1242.   PL_DLPWriteByte(socket,0x40);
  1243.   PL_DLPWriteLong(socket,(LONG)type);
  1244.   PL_DLPWriteWord(socket,(WORD)id);
  1245.   PL_DLPWriteWord(socket,0);
  1246.   PL_DLPWriteWord(socket,(buffer ? 0xFFFF : 0));
  1247.   if((reply=PL_DLPSend(socket,0x23,0x21)) == -1) return(-1);
  1248.   PL_DLPRead(socket,NULL,6);
  1249.   PL_DLPRead(socket,index,2);
  1250.   PL_DLPRead(socket,size,2);
  1251.   PL_DLPRead(socket,buffer,reply-10);
  1252.   return(reply-10);
  1253. }
  1254. //<
  1255.  
  1256. /*------------------------------------------------------**
  1257. ** Name:        DLP_ReadResourceByIndex
  1258. **
  1259. ** Funktion:    Liest eine Resource nach Index
  1260. **
  1261. ** Parameter:   socket    Socket für die Übertragung
  1262. **              handle    DBHandle
  1263. **              index     Index
  1264. **              buffer    Zielpuffer
  1265. **              type      Typ
  1266. **              id
  1267. **              size
  1268. ** Ergebnis:    length    Datenpaket
  1269. //>
  1270. ** Bemerkungen:
  1271. **
  1272. ** Revision:    13. Juni 1998, 00:52:51
  1273. */
  1274. __saveds __asm LONG DLP_ReadResourceByIndex
  1275. (
  1276.   register __a0 APTR socket,
  1277.   register __d0 LONG handle,
  1278.   register __d1 UWORD index,
  1279.   register __a1 APTR buffer,
  1280.   register __a2 ULONG *type,
  1281.   register __a3 UWORD *id,
  1282.   register __d2 UWORD *size
  1283. )
  1284. {
  1285.   LONG reply;
  1286.  
  1287.   PL_DLPInit(socket);
  1288.   PL_DLPWriteByte(socket,(BYTE)handle);
  1289.   PL_DLPWriteByte(socket,0x00);
  1290.   PL_DLPWriteWord(socket,(WORD)index);
  1291.   PL_DLPWriteWord(socket,0);
  1292.   PL_DLPWriteWord(socket,(buffer ? 0xFFFF : 0));
  1293.   if((reply=PL_DLPSend(socket,0x23,0x20)) == -1) return(-1);
  1294.   PL_DLPRead(socket,type,4);
  1295.   PL_DLPRead(socket,id,2);
  1296.   PL_DLPRead(socket,NULL,2);
  1297.   PL_DLPRead(socket,size,2);
  1298.   PL_DLPRead(socket,buffer,reply-10);
  1299.   return(reply-10);
  1300. }
  1301. //<
  1302.  
  1303. /*------------------------------------------------------**
  1304. ** Name:        DLP_WriteResource
  1305. **
  1306. ** Funktion:    Schreibt eine Resource
  1307. **
  1308. ** Parameter:   socket    Socket für die Übertragung
  1309. **              handle    DBHandle
  1310. **              type      Typ
  1311. **              id
  1312. **              buffer    Datenbuffer
  1313. **              length    Länge des Pakets
  1314. ** Ergebnis:    success
  1315. //>
  1316. ** Bemerkungen:
  1317. **
  1318. ** Revision:    13. Juni 1998, 17:58:49
  1319. */
  1320. __saveds __asm int DLP_WriteResource
  1321. (
  1322.   register __a0 APTR socket,
  1323.   register __d0 LONG handle,
  1324.   register __d1 ULONG type,
  1325.   register __d2 UWORD id,
  1326.   register __a1 APTR buffer,
  1327.   register __d3 UWORD length
  1328. )
  1329. {
  1330.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1331.  
  1332.   PL_DLPInit(socket);
  1333.   PL_DLPWriteByte(socket,(BYTE)handle);
  1334.   PL_DLPWriteByte(socket,0x00);
  1335.   PL_DLPWriteLong(socket,(LONG)type);
  1336.   PL_DLPWriteWord(socket,id);
  1337.   PL_DLPWriteWord(socket,length);
  1338.   if(!PL_DLPTstWrite(socket,length))
  1339.   {
  1340.     sock->lastError = PLERR_TOOLARGE;
  1341.     return(FALSE);
  1342.   }
  1343.   PL_DLPWrite(socket,buffer,length);
  1344.   return(PL_DLPSend(socket,0x24,0x20) != -1);
  1345. }
  1346. //<
  1347.  
  1348. /*------------------------------------------------------**
  1349. ** Name:        DLP_DeleteResource
  1350. **
  1351. ** Funktion:    Löscht eine Resource
  1352. **
  1353. ** Parameter:   socket    Socket für die Übertragung
  1354. **              handle    DBHandle
  1355. **              all       Alle Resourcen
  1356. **              restype   Resource-Typ
  1357. **              resid     Resource-ID
  1358. ** Ergebnis:    success
  1359. //>
  1360. ** Bemerkungen:
  1361. **
  1362. ** Revision:    13. Juni 1998, 18:34:17
  1363. */
  1364. __saveds __asm int DLP_DeleteResource
  1365. (
  1366.   register __a0 APTR socket,
  1367.   register __d0 LONG handle,
  1368.   register __d1 BOOL all,
  1369.   register __d2 ULONG restype,
  1370.   register __d3 UWORD resid
  1371. )
  1372. {
  1373.   PL_DLPInit(socket);
  1374.   PL_DLPWriteByte(socket,(BYTE)handle);
  1375.   PL_DLPWriteByte(socket,(all ? 0x80 : 0x00));
  1376.   PL_DLPWriteLong(socket,(LONG)restype);
  1377.   PL_DLPWriteWord(socket,(WORD)resid);
  1378.   return(PL_DLPSend(socket,0x25,0x20) != -1);
  1379. }
  1380. //<
  1381.  
  1382. /*------------------------------------------------------**
  1383. ** Name:        DLP_ReadAppBlock
  1384. **
  1385. ** Funktion:    Liest einen AppBlock (?)
  1386. **
  1387. ** Parameter:   socket    Socket für die Übertragung
  1388. **              handle    DBHandle
  1389. **              offset    Offset
  1390. **              buffer    Zielpuffer
  1391. **              length    Puffergröße
  1392. ** Ergebnis:    length    Datenpaket
  1393. //>
  1394. ** Bemerkungen:
  1395. **
  1396. ** Revision:    13. Juni 1998, 18:44:41
  1397. */
  1398. __saveds __asm LONG DLP_ReadAppBlock
  1399. (
  1400.   register __a0 APTR socket,
  1401.   register __d0 LONG handle,
  1402.   register __d1 UWORD offset,
  1403.   register __a1 APTR buffer,
  1404.   register __d2 UWORD length
  1405. )
  1406. {
  1407.   LONG reply;
  1408.  
  1409.   PL_DLPInit(socket);
  1410.   PL_DLPWriteByte(socket,(BYTE)handle);
  1411.   PL_DLPWriteByte(socket,0x00);
  1412.   PL_DLPWriteWord(socket,(WORD)offset);
  1413.   PL_DLPWriteWord(socket,(WORD)length);
  1414.   if((reply=PL_DLPSend(socket,0x1B,0x20)) == -1) return(-1);
  1415.   if(buffer)
  1416.   {
  1417.     PL_DLPRead(socket,NULL,2);
  1418.     PL_DLPRead(socket,buffer,reply-2);
  1419.   }
  1420.   return(reply-2);
  1421. }
  1422. //<
  1423. /*------------------------------------------------------**
  1424. ** Name:        DLP_WriteAppBlock
  1425. **
  1426. ** Funktion:    Schreibt einen AppBlock
  1427. **
  1428. ** Parameter:   socket    Socket für die Übertragung
  1429. **              handle    DBHandle
  1430. **              buffer    Datenbuffer
  1431. **              length    Länge des Pakets
  1432. ** Ergebnis:    success
  1433. //>
  1434. ** Bemerkungen:
  1435. **
  1436. ** Revision:    13. Juni 1998, 17:58:49
  1437. */
  1438. __saveds __asm int DLP_WriteAppBlock
  1439. (
  1440.   register __a0 APTR socket,
  1441.   register __d0 LONG handle,
  1442.   register __a1 APTR buffer,
  1443.   register __d1 UWORD length
  1444. )
  1445. {
  1446.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1447.  
  1448.   PL_DLPInit(socket);
  1449.   PL_DLPWriteByte(socket,(BYTE)handle);
  1450.   PL_DLPWriteByte(socket,0x00);
  1451.   PL_DLPWriteWord(socket,(WORD)length);
  1452.   if(!PL_DLPTstWrite(socket,length))
  1453.   {
  1454.     sock->lastError = PLERR_TOOLARGE;
  1455.     return(FALSE);
  1456.   }
  1457.   PL_DLPWrite(socket,buffer,length);
  1458.   return(PL_DLPSend(socket,0x1C,0x20) != -1);
  1459. }
  1460. //<
  1461.  
  1462. /*------------------------------------------------------**
  1463. ** Name:        DLP_ReadSortBlock
  1464. **
  1465. ** Funktion:    Liest einen SortBlock (?)
  1466. **
  1467. ** Parameter:   socket    Socket für die Übertragung
  1468. **              handle    DBHandle
  1469. **              offset    Offset
  1470. **              buffer    Zielpuffer
  1471. **              length    Puffergröße
  1472. ** Ergebnis:    length    Datenpaket
  1473. //>
  1474. ** Bemerkungen:
  1475. **
  1476. ** Revision:    13. Juni 1998, 18:44:41
  1477. */
  1478. __saveds __asm LONG DLP_ReadSortBlock
  1479. (
  1480.   register __a0 APTR socket,
  1481.   register __d0 LONG handle,
  1482.   register __d1 UWORD offset,
  1483.   register __a1 APTR buffer,
  1484.   register __d2 UWORD length
  1485. )
  1486. {
  1487.   LONG reply;
  1488.  
  1489.   PL_DLPInit(socket);
  1490.   PL_DLPWriteByte(socket,(BYTE)handle);
  1491.   PL_DLPWriteByte(socket,0x00);
  1492.   PL_DLPWriteWord(socket,(WORD)offset);
  1493.   PL_DLPWriteWord(socket,(WORD)length);
  1494.   if((reply=PL_DLPSend(socket,0x1D,0x20)) == -1) return(-1);
  1495.   if(buffer)
  1496.   {
  1497.     PL_DLPRead(socket,NULL,2);
  1498.     PL_DLPRead(socket,buffer,reply-2);
  1499.   }
  1500.   return(reply-2);
  1501. }
  1502. //<
  1503. /*------------------------------------------------------**
  1504. ** Name:        DLP_WriteSortBlock
  1505. **
  1506. ** Funktion:    Schreibt einen SortBlock
  1507. **
  1508. ** Parameter:   socket    Socket für die Übertragung
  1509. **              handle    DBHandle
  1510. **              buffer    Datenbuffer
  1511. **              length    Länge des Pakets
  1512. ** Ergebnis:    success
  1513. //>
  1514. ** Bemerkungen:
  1515. **
  1516. ** Revision:    13. Juni 1998, 19:09:25
  1517. */
  1518. __saveds __asm int DLP_WriteSortBlock
  1519. (
  1520.   register __a0 APTR socket,
  1521.   register __d0 LONG handle,
  1522.   register __a1 APTR buffer,
  1523.   register __d1 UWORD length
  1524. )
  1525. {
  1526.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1527.  
  1528.   PL_DLPInit(socket);
  1529.   PL_DLPWriteByte(socket,(BYTE)handle);
  1530.   PL_DLPWriteByte(socket,0x00);
  1531.   PL_DLPWriteWord(socket,(WORD)length);
  1532.   if(!PL_DLPTstWrite(socket,length))
  1533.   {
  1534.     sock->lastError = PLERR_TOOLARGE;
  1535.     return(FALSE);
  1536.   }
  1537.   PL_DLPWrite(socket,buffer,length);
  1538.   return(PL_DLPSend(socket,0x1E,0x20) != -1);
  1539. }
  1540. //<
  1541.  
  1542. /*------------------------------------------------------**
  1543. ** Name:        DLP_CleanUpDatabase
  1544. **
  1545. ** Funktion:    Säubert die Datenbank
  1546. **
  1547. ** Parameter:   socket    Socket für die Übertragung
  1548. **              handle    DBHandle
  1549. ** Ergebnis:    success
  1550. //>
  1551. ** Bemerkungen:
  1552. **
  1553. ** Revision:    13. Juni 1998, 19:11:45
  1554. */
  1555. __saveds __asm int DLP_CleanUpDatabase
  1556. (
  1557.   register __a0 APTR socket,
  1558.   register __d0 LONG handle
  1559. )
  1560. {
  1561.   PL_DLPInit(socket);
  1562.   PL_DLPWriteByte(socket,(BYTE)handle);
  1563.   return(PL_DLPSend(socket,0x26,0x20) != -1);
  1564. }
  1565. //<
  1566. /*------------------------------------------------------**
  1567. ** Name:        DLP_ResetSyncFlags
  1568. **
  1569. ** Funktion:    Säubert die Datenbank
  1570. **
  1571. ** Parameter:   socket    Socket für die Übertragung
  1572. **              handle    DBHandle
  1573. ** Ergebnis:    success
  1574. //>
  1575. ** Bemerkungen:
  1576. **
  1577. ** Revision:    13. Juni 1998, 19:11:45
  1578. */
  1579. __saveds __asm int DLP_ResetSyncFlags
  1580. (
  1581.   register __a0 APTR socket,
  1582.   register __d0 LONG handle
  1583. )
  1584. {
  1585.   PL_DLPInit(socket);
  1586.   PL_DLPWriteByte(socket,(BYTE)handle);
  1587.   return(PL_DLPSend(socket,0x27,0x20) != -1);
  1588. }
  1589. //<
  1590.  
  1591. /*------------------------------------------------------**
  1592. ** Name:        DLP_ReadNextCatRecord
  1593. **
  1594. ** Funktion:    Liest den nächsten Record der Kategorie
  1595. **
  1596. ** Parameter:   socket    Socket für die Übertragung
  1597. **              handle    DBHandle
  1598. **              cat       Kategorie
  1599. **              buffer    Zielpuffer
  1600. **              id        Platz für Record-ID
  1601. **              index     Platz für Record-Index
  1602. **              size      Platz für Record-Size
  1603. **              attr      Platz für Record-Attribut
  1604. ** Ergebnis:    length    Datenpaket
  1605. //>
  1606. ** Bemerkungen:
  1607. **
  1608. ** Revision:    13. Juni 1998, 19:26:14
  1609. */
  1610. __saveds __asm LONG DLP_ReadNextCatRecord
  1611. (
  1612.   register __a0 APTR socket,
  1613.   register __d0 LONG handle,
  1614.   register __d1 UBYTE cat,
  1615.   register __a1 APTR buffer,
  1616.   register __a2 ULONG *id,
  1617.   register __a3 UWORD *index,
  1618.   register __d2 UWORD *size,
  1619.   register __d3 UBYTE *attr
  1620. )
  1621. {
  1622.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1623.   LONG reply;
  1624.  
  1625.   if(sock->version < 0x0101)
  1626.   {
  1627.     /*TODO: write PalmOS 1 emulation code */
  1628.     sock->lastError = PLERR_OS2REQUIRED;
  1629.     return(FALSE);
  1630.   }
  1631.  
  1632.   PL_DLPInit(socket);
  1633.   PL_DLPWriteByte(socket,(BYTE)handle);
  1634.   PL_DLPWriteByte(socket,(BYTE)cat);
  1635.   if((reply=PL_DLPSend(socket,0x32,0x20)) == -1) return(-1);
  1636.   PL_DLPRead(socket,id,4);
  1637.   PL_DLPRead(socket,index,2);
  1638.   PL_DLPRead(socket,size,2);
  1639.   PL_DLPRead(socket,attr,1);
  1640.   if(buffer)
  1641.   {
  1642.     PL_DLPRead(socket,NULL,1);
  1643.     PL_DLPRead(socket,buffer,reply-10);
  1644.   }
  1645.   return(reply-10);
  1646. }
  1647. //<
  1648.  
  1649. /*------------------------------------------------------**
  1650. ** Name:        DLP_ReadAppPreference
  1651. **
  1652. ** Funktion:    Liest die Prefs einer App
  1653. **
  1654. ** Parameter:   socket    Socket für die Übertragung
  1655. **              creator   Erzeuger-ID
  1656. **              id        ID
  1657. **              backup    ??
  1658. **              maxsize   Maximale Größe
  1659. **              buffer    Zielpuffer
  1660. **              size      Platz für Größe
  1661. **              version   Platz für Version
  1662. ** Ergebnis:    length    Datenpaket
  1663. //>
  1664. ** Bemerkungen:
  1665. **
  1666. ** Revision:    13. Juni 1998, 20:36:57
  1667. */
  1668. __saveds __asm LONG DLP_ReadAppPreference
  1669. (
  1670.   register __a0 APTR socket,
  1671.   register __d0 ULONG creator,
  1672.   register __d1 UWORD id,
  1673.   register __d2 BOOL backup,
  1674.   register __d3 UWORD maxsize,
  1675.   register __a1 APTR buffer,
  1676.   register __a2 UWORD *size,
  1677.   register __a3 UWORD *version
  1678. )
  1679. {
  1680.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1681.   UWORD stotal, sreturn;
  1682.  
  1683.   if(sock->version < 0x0101)
  1684.   {
  1685.     /*TODO: write PalmOS 1 emulation code */
  1686.     sock->lastError = PLERR_OS2REQUIRED;
  1687.     return(FALSE);
  1688.   }
  1689.  
  1690.   PL_DLPInit(socket);
  1691.   PL_DLPWriteLong(socket,(LONG)creator);
  1692.   PL_DLPWriteWord(socket,(WORD)id);
  1693.   PL_DLPWriteWord(socket,(buffer ? maxsize : 0));
  1694.   PL_DLPWriteByte(socket,(backup ? 0x80 : 0x00));
  1695.   PL_DLPWriteByte(socket,0);
  1696.   if(PL_DLPSend(socket,0x34,0x20) == -1) return(-1);
  1697.   PL_DLPRead(socket,version,2);
  1698.   PL_DLPRead(socket,&stotal,2);
  1699.   PL_DLPRead(socket,&sreturn,2);
  1700.   if(buffer)
  1701.   {
  1702.     PL_DLPRead(socket,buffer,sreturn);
  1703.     *size = sreturn;
  1704.   }
  1705.   else
  1706.   {
  1707.     *size = stotal;
  1708.   }
  1709.   return(sreturn);
  1710. }
  1711. //<
  1712. /*------------------------------------------------------**
  1713. ** Name:        DLP_WriteAppPreference
  1714. **
  1715. ** Funktion:    Schreibt die Prefs einer App
  1716. **
  1717. ** Parameter:   socket    Socket für die Übertragung
  1718. **              creator   Erzeuger-ID
  1719. **              id        ID
  1720. **              backup    ??
  1721. **              version   Versionsnr.
  1722. **              buffer    Zielpuffer
  1723. **              size      Größe
  1724. ** Ergebnis:    success
  1725. //>
  1726. ** Bemerkungen:
  1727. **
  1728. ** Revision:    13. Juni 1998, 20:36:57
  1729. */
  1730. __saveds __asm int DLP_WriteAppPreference
  1731. (
  1732.   register __a0 APTR socket,
  1733.   register __d0 ULONG creator,
  1734.   register __d1 UWORD id,
  1735.   register __d2 BOOL backup,
  1736.   register __d3 UWORD version,
  1737.   register __a1 APTR buffer,
  1738.   register __d4 UWORD length
  1739. )
  1740. {
  1741.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1742.  
  1743.   if(sock->version < 0x0101)
  1744.   {
  1745.     /*TODO: write PalmOS 1 emulation code */
  1746.     sock->lastError = PLERR_OS2REQUIRED;
  1747.     return(FALSE);
  1748.   }
  1749.  
  1750.   PL_DLPInit(socket);
  1751.   PL_DLPWriteLong(socket,(LONG)creator);
  1752.   PL_DLPWriteWord(socket,(WORD)id);
  1753.   PL_DLPWriteWord(socket,(WORD)version);
  1754.   PL_DLPWriteWord(socket,(WORD)length);
  1755.   PL_DLPWriteByte(socket,(backup ? 0x80 : 0x00));
  1756.   PL_DLPWriteByte(socket,0);
  1757.   if(!PL_DLPTstWrite(socket,length))
  1758.   {
  1759.     sock->lastError = PLERR_TOOLARGE;
  1760.     return(FALSE);
  1761.   }
  1762.   PL_DLPWrite(socket,buffer,length);
  1763.   return(PL_DLPSend(socket,0x35,0x20) != -1);
  1764. }
  1765. //<
  1766.  
  1767. /*------------------------------------------------------**
  1768. ** Name:        DLP_ReadNextModifiedCatRecord
  1769. **
  1770. ** Funktion:    Liest den nächsten modifizierten Record der Kategorie
  1771. **
  1772. ** Parameter:   socket    Socket für die Übertragung
  1773. **              handle    DBHandle
  1774. **              cat       Kategorie
  1775. **              buffer    Zielpuffer
  1776. **              id        Platz für Record-ID
  1777. **              index     Platz für Record-Index
  1778. **              size      Platz für Record-Size
  1779. **              attr      Platz für Record-Attribut
  1780. ** Ergebnis:    length    Datenpaket
  1781. //>
  1782. ** Bemerkungen:
  1783. **
  1784. ** Revision:    13. Juni 1998, 20:56:03
  1785. */
  1786. __saveds __asm LONG DLP_ReadNextModifiedCatRecord
  1787. (
  1788.   register __a0 APTR socket,
  1789.   register __d0 LONG handle,
  1790.   register __d1 UBYTE cat,
  1791.   register __a1 APTR buffer,
  1792.   register __a2 ULONG *id,
  1793.   register __a3 UWORD *index,
  1794.   register __d2 UWORD *size,
  1795.   register __d3 UBYTE *attr
  1796. )
  1797. {
  1798.   struct PL_Socket *sock = (struct PL_Socket *)socket;
  1799.   LONG reply;
  1800.  
  1801.   if(sock->version < 0x0101)
  1802.   {
  1803.     /*TODO: write PalmOS 1 emulation code */
  1804.     sock->lastError = PLERR_OS2REQUIRED;
  1805.     return(FALSE);
  1806.   }
  1807.  
  1808.   PL_DLPInit(socket);
  1809.   PL_DLPWriteByte(socket,(BYTE)handle);
  1810.   PL_DLPWriteByte(socket,(BYTE)cat);
  1811.   if((reply=PL_DLPSend(socket,0x33,0x20)) == -1) return(-1);
  1812.   PL_DLPRead(socket,id,4);
  1813.   PL_DLPRead(socket,index,2);
  1814.   PL_DLPRead(socket,size,2);
  1815.   PL_DLPRead(socket,attr,1);
  1816.   if(buffer)
  1817.   {
  1818.     PL_DLPRead(socket,NULL,1);
  1819.     PL_DLPRead(socket,buffer,reply-10);
  1820.   }
  1821.   return(reply-10);
  1822. }
  1823. //<
  1824.  
  1825. /*------------------------------------------------------**
  1826. ** Name:        DLP_ReadRecordByID
  1827. **
  1828. ** Funktion:    Liest einen Eintrag per ID
  1829. **
  1830. ** Parameter:   socket    Socket für die Übertragung
  1831. **              handle    DBHandle
  1832. **              id        Record-ID
  1833. **              buffer    Zielpuffer
  1834. **              index     Platz für Record-Index
  1835. **              size      Platz für Record-Size
  1836. **              attr      Platz für Record-Attribut
  1837. **              cat       Platz für Kategoriecode
  1838. ** Ergebnis:    length    Datenpaket
  1839. //>
  1840. ** Bemerkungen:
  1841. **
  1842. ** Revision:    13. Juni 1998, 20:56:03
  1843. */
  1844. __saveds __asm LONG DLP_ReadRecordByID
  1845. (
  1846.   register __a0 APTR socket,
  1847.   register __d0 LONG handle,
  1848.   register __d1 ULONG id,
  1849.   register __a1 APTR buffer,
  1850.   register __a2 UWORD *index,
  1851.   register __a3 UWORD *size,
  1852.   register __d2 UBYTE *attr,
  1853.   register __d3 UBYTE *cat
  1854. )
  1855. {
  1856.   LONG reply;
  1857.  
  1858.   PL_DLPInit(socket);
  1859.   PL_DLPWriteByte(socket,(BYTE)handle);
  1860.   PL_DLPWriteByte(socket,0);
  1861.   PL_DLPWriteLong(socket,4);
  1862.   PL_DLPWriteWord(socket,0);
  1863.   PL_DLPWriteWord(socket,(buffer ? 0xFFFF : 0));
  1864.   if((reply=PL_DLPSend(socket,0x20,0x20)) == -1) return(-1);
  1865.   PL_DLPRead(socket,NULL,4);
  1866.   PL_DLPRead(socket,index,2);
  1867.   PL_DLPRead(socket,size,2);
  1868.   PL_DLPRead(socket,attr,1);
  1869.   PL_DLPRead(socket,cat,1);
  1870.   if(buffer)
  1871.   {
  1872.     PL_DLPRead(socket,buffer,reply-10);
  1873.   }
  1874.   return(reply-10);
  1875. }
  1876. //<
  1877. /*------------------------------------------------------**
  1878. ** Name:        DLP_ReadRecordByIndex
  1879. **
  1880. ** Funktion:    Liest einen Eintrag per Index
  1881. **
  1882. ** Parameter:   socket    Socket für die Übertragung
  1883. **              handle    DBHandle
  1884. **              index     Record-Index
  1885. **              buffer    Zielpuffer
  1886. **              size      Platz für Record-Size
  1887. **              attr      Platz für Record-Attribut
  1888. **              cat       Platz für Kategoriecode
  1889. **              id        Platz für Record-ID
  1890. ** Ergebnis:    length    Datenpaket
  1891. //>
  1892. ** Bemerkungen:
  1893. **
  1894. ** Revision:    13. Juni 1998, 20:56:03
  1895. */
  1896. __saveds __asm LONG DLP_ReadRecordByIndex
  1897. (
  1898.   register __a0 APTR socket,
  1899.   register __d0 LONG handle,
  1900.   register __d1 UWORD index,
  1901.   register __a1 APTR buffer,
  1902.   register __a2 ULONG *id,
  1903.   register __a3 UWORD *size,
  1904.   register __d2 UBYTE *attr,
  1905.   register __d3 UBYTE *cat
  1906. )
  1907. {
  1908.   LONG reply;
  1909.  
  1910.   PL_DLPInit(socket);
  1911.   PL_DLPWriteByte(socket,(BYTE)handle);
  1912.   PL_DLPWriteByte(socket,0);
  1913.   PL_DLPWriteWord(socket,(WORD)index);
  1914.   PL_DLPWriteWord(socket,0);
  1915.   PL_DLPWriteWord(socket,(buffer ? 0xFFFF : 0));
  1916.   if((reply=PL_DLPSend(socket,0x20,0x21)) == -1) return(-1);
  1917.   PL_DLPRead(socket,id,4);
  1918.   PL_DLPRead(socket,NULL,2);
  1919.   PL_DLPRead(socket,size,2);
  1920.   PL_DLPRead(socket,attr,1);
  1921.   PL_DLPRead(socket,cat,1);
  1922.   if(buffer)
  1923.   {
  1924.     PL_DLPRead(socket,buffer,reply-10);
  1925.   }
  1926.   return(reply-10);
  1927. }
  1928. //<
  1929.  
  1930. /*------------------------------------------------------**
  1931. ** Name:        DLP_UnpackCategoryAppInfo
  1932. **
  1933. ** Funktion:    Entpackt eine Category AppInfo-Struktur
  1934. **
  1935. ** Parameter:   cai       Platz für CategoryAppInfo
  1936. **              record    Zeiger auf Record
  1937. **              length    Länge des Records
  1938. ** Ergebnis:    length    Länge des Category AppInfos
  1939. //>
  1940. ** Bemerkungen:
  1941. **
  1942. ** Revision:     2. März 1999, 23:45:04
  1943. */
  1944. __saveds __asm LONG DLP_UnpackCategoryAppInfo
  1945. (
  1946.   register __a0 struct PL_CategoryAppInfo *cai,
  1947.   register __a1 APTR record,
  1948.   register __d0 LONG length
  1949. )
  1950. {
  1951.   if(length < sizeof(struct PL_CategoryAppInfo))
  1952.     return 0;                                     // Zu kurz
  1953.  
  1954.   CopyMem(record,cai,sizeof(struct PL_CategoryAppInfo));
  1955.   return sizeof(struct PL_CategoryAppInfo);
  1956. }
  1957. //<
  1958. /*------------------------------------------------------**
  1959. ** Name:        DLP_PackCategoryAppInfo
  1960. **
  1961. ** Funktion:    Packt eine Category AppInfo-Struktur
  1962. **
  1963. ** Parameter:   cai       Zeiger auf CategoryAppInfo
  1964. **              record    Zeiger auf Record, oder NULL,
  1965. **                        um die Größe herauszufinden
  1966. **              length    Länge des Records
  1967. ** Ergebnis:    length    Länge des Category AppInfos
  1968. //>
  1969. ** Bemerkungen:
  1970. **
  1971. ** Revision:     2. März 1999, 23:45:04
  1972. */
  1973. __saveds __asm LONG DLP_PackCategoryAppInfo
  1974. (
  1975.   register __a0 struct PL_CategoryAppInfo *cai,
  1976.   register __a1 APTR record,
  1977.   register __d0 LONG length
  1978. )
  1979. {
  1980.   if(!record)
  1981.     return sizeof(struct PL_CategoryAppInfo);
  1982.   if(length < sizeof(struct PL_CategoryAppInfo))
  1983.     return 0;                                     // Too short
  1984.  
  1985.   CopyMem(cai,record,sizeof(struct PL_CategoryAppInfo));
  1986.   return sizeof(struct PL_CategoryAppInfo);
  1987. }
  1988. //<
  1989.  
  1990.  
  1991.  
  1992.  
  1993. /********************************************************************/
  1994.