home *** CD-ROM | disk | FTP | other *** search
/ PC Online 1997 August / PCO0897.ISO / filesbbs / os2 / plnk065.arj / PLNK065.ZIP / pilot-link.0.6.5 / Python / pdapilot.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-23  |  52.1 KB  |  2,493 lines
  1. #include "Python.h"
  2. #include "pi-source.h"
  3. #include "pi-dlp.h"
  4. #include "pi-file.h"
  5. #include "pi-memo.h"
  6. #include "pi-todo.h"
  7. #include "pi-socket.h"
  8. #include "pi-syspkt.h"
  9.  
  10. extern char * printlong (unsigned long val);
  11. extern unsigned long makelong (char * c);
  12.  
  13. static PyObject * Error;
  14.  
  15. static PyObject * DBPackers;
  16. static PyObject * PrefPackers;
  17.  
  18. static PyMethodDef PiFile_methods[];
  19.  
  20. static PyMethodDef Dlp_methods[];
  21.  
  22. static PyMethodDef DlpDB_methods[];
  23.  
  24. typedef struct {
  25.     PyObject_HEAD
  26.     struct pi_file    *pf;
  27.  
  28.     PyObject *Pack, *Unpack, *PackAppBlock, *UnpackAppBlock;
  29. } PiFileObject;
  30.  
  31. staticforward PyTypeObject PiFile_Type;
  32.  
  33. #define PiFileObject_Check(v) ((v)->ob_type == &PiFile_Type)
  34.  
  35. typedef struct {
  36.     PyObject_HEAD
  37.  
  38.     struct RPC_params * p;
  39. } RpcObject;
  40.  
  41. staticforward PyTypeObject Rpc_Type;
  42.  
  43. #define RpcObject_Check(v) ((v)->ob_type == &Rpc_Type)
  44.  
  45. typedef struct {
  46.     PyObject_HEAD
  47.     void * buffer;
  48.     int socket;
  49. } DlpObject;
  50.  
  51. typedef struct {
  52.     PyObject_HEAD
  53.     DlpObject * socket;
  54.     int handle;
  55.     
  56.     PyObject *Pack, *Unpack, *PackAppBlock, *UnpackAppBlock;
  57. } DlpDBObject;
  58.  
  59. staticforward PyTypeObject Dlp_Type;
  60.  
  61. #define DlpObject_Check(v) ((v)->ob_type == &Dlp_Type)
  62.  
  63. staticforward PyTypeObject DlpDB_Type;
  64.  
  65. #define DlpDBObject_Check(v) ((v)->ob_type == &DlpDB_Type)
  66.  
  67. static void
  68. PiFile_dealloc(self)
  69.     PiFileObject *self;
  70. {
  71.     Py_XDECREF(self->Pack);
  72.     Py_XDECREF(self->Unpack);
  73.     Py_XDECREF(self->PackAppBlock);
  74.     Py_XDECREF(self->UnpackAppBlock);
  75.     if (self->pf)
  76.         pi_file_close(self->pf);
  77.     PyMem_DEL(self);
  78. }
  79.  
  80. static void
  81. Rpc_dealloc(self)
  82.     RpcObject *self;
  83. {
  84.     if (self->p)
  85.         free(self->p);
  86.     PyMem_DEL(self);
  87. }
  88.  
  89. static void
  90. Dlp_dealloc(self)
  91.     DlpObject *self;
  92. {
  93.     if (self->buffer)
  94.         free(self->buffer);
  95.     if (self->socket)
  96.         pi_close(self->socket);
  97.     PyMem_DEL(self);
  98. }
  99.  
  100. static void
  101. DlpDB_dealloc(self)
  102.     DlpDBObject *self;
  103. {
  104.     Py_XDECREF(self->Pack);
  105.     Py_XDECREF(self->Unpack);
  106.     Py_XDECREF(self->PackAppBlock);
  107.     Py_XDECREF(self->UnpackAppBlock);
  108.     if (self->handle)
  109.         dlp_CloseDB(self->socket->socket, self->handle);
  110.     if (self->socket)
  111.         Py_DECREF(self->socket);
  112.     PyMem_DEL(self);
  113. }
  114.  
  115. static PyObject *
  116. PiFile_getattr(self, name)
  117.     PyObject * self;
  118.     char * name;
  119. {
  120.     return Py_FindMethod(PiFile_methods, (PyObject *)self, name);
  121. }
  122.  
  123.  
  124. staticforward PyTypeObject PiFile_Type = {
  125.         PyObject_HEAD_INIT(&PyType_Type)
  126.         0,            /*ob_size*/
  127.         "pdapilot.file",        /*tp_name*/
  128.     sizeof(PiFileObject),    /*tp_basicsize*/
  129.         0,            /*tp_itemsize*/
  130.                 /* methods */
  131.     (destructor)PiFile_dealloc,    /*tp_dealloc*/
  132.     0,            /*tp_print*/
  133.     (getattrfunc)PiFile_getattr,    /*tp_getattr*/
  134.     0,            /*tp_setattr*/
  135.     0,            /*tp_compare*/
  136.     0,            /*tp_repr*/
  137.     0,            /*tp_as_number*/
  138.     0,            /*tp_as_sequence*/
  139.     0,            /*tp_as_mapping*/
  140.     0,            /*tp_hash*/
  141. };
  142.  
  143. staticforward PyTypeObject Rpc_Type = {
  144.         PyObject_HEAD_INIT(&PyType_Type)
  145.         0,            /*ob_size*/
  146.         "pdapilot.rpc",        /*tp_name*/
  147.     sizeof(RpcObject),    /*tp_basicsize*/
  148.         0,            /*tp_itemsize*/
  149.                 /* methods */
  150.     (destructor)Rpc_dealloc,    /*tp_dealloc*/
  151.     0,            /*tp_print*/
  152.     0,            /*tp_getattr*/
  153.     0,            /*tp_setattr*/
  154.     0,            /*tp_compare*/
  155.     0,            /*tp_repr*/
  156.     0,            /*tp_as_number*/
  157.     0,            /*tp_as_sequence*/
  158.     0,            /*tp_as_mapping*/
  159.     0,            /*tp_hash*/
  160. };
  161.  
  162. static PyObject *
  163. Dlp_getattr(self, name)
  164.     PyObject * self;
  165.     char * name;
  166. {
  167.     return Py_FindMethod(Dlp_methods, (PyObject *)self, name);
  168. }
  169.  
  170. staticforward PyTypeObject Dlp_Type = {
  171.     PyObject_HEAD_INIT(&PyType_Type)
  172.     0,            /*ob_size*/
  173.     "pdapilot.dlp",        /*tp_name*/
  174.     sizeof(DlpObject),    /*tp_basicsize*/
  175.     0,            /*tp_itemsize*/
  176.                 /* methods */
  177.     (destructor)Dlp_dealloc,    /*tp_dealloc*/
  178.     0,            /*tp_print*/
  179.     (getattrfunc)Dlp_getattr,    /*tp_getattr*/
  180.     0,            /*tp_setattr*/
  181.     0,            /*tp_compare*/
  182.     0,            /*tp_repr*/
  183.     0,            /*tp_as_number*/
  184.     0,            /*tp_as_sequence*/
  185.     0,            /*tp_as_mapping*/
  186.     0,            /*tp_hash*/
  187. };
  188.  
  189. static PyObject *
  190. DlpDB_getattr(self, name)
  191.     DlpDBObject * self;
  192.     char * name;
  193. {
  194.     return Py_FindMethod(DlpDB_methods, (PyObject *)self, name);
  195. }
  196.  
  197. staticforward PyTypeObject DlpDB_Type = {
  198.     PyObject_HEAD_INIT(&PyType_Type)
  199.     0,            /*ob_size*/
  200.     "pdapilot.dlp.db",    /*tp_name*/
  201.     sizeof(DlpDBObject),    /*tp_basicsize*/
  202.     0,            /*tp_itemsize*/
  203.                 /* methods */
  204.     (destructor)DlpDB_dealloc,    /*tp_dealloc*/
  205.     0,            /*tp_print*/
  206.     (getattrfunc)DlpDB_getattr,    /*tp_getattr*/
  207.     0,            /*tp_setattr*/
  208.     0,            /*tp_compare*/
  209.     0,            /*tp_repr*/
  210.     0,            /*tp_as_number*/
  211.     0,            /*tp_as_sequence*/
  212.     0,            /*tp_as_mapping*/
  213.     0,            /*tp_hash*/
  214. };
  215.  
  216. static PyObject *
  217. Socket(self, args)
  218.     PyObject *self;
  219.     PyObject *args;
  220. {
  221.     int domain,type,protocol,result;
  222.     if (!PyArg_ParseTuple(args, "iii", &domain,&type,&protocol))
  223.         return NULL;
  224.     result = pi_socket(domain,type,protocol);
  225.     if (result==-1) {
  226.         PyErr_SetFromErrno(Error);
  227.         return NULL;
  228.     } else
  229.         return Py_BuildValue("i", result);
  230. }
  231.  
  232. static PyObject *
  233. CloseSocket(self, args)
  234.     PyObject *self;
  235.     PyObject *args;
  236. {
  237.     int socket,result;
  238.     if (!PyArg_ParseTuple(args, "i", &socket))
  239.         return NULL;
  240.     result = pi_close(socket);
  241.     if (result==-1) {
  242.         PyErr_SetFromErrno(Error);
  243.         return NULL;
  244.     } else
  245.         return Py_BuildValue("i", result);
  246. }
  247.  
  248. static PyObject *
  249. Read(self, args)
  250.     PyObject *self;
  251.     PyObject *args;
  252. {
  253.     int length,socket,result;
  254.     char * data;
  255.     if (!PyArg_ParseTuple(args, "is#", &socket, &data, &length))
  256.         return NULL;
  257.     result = pi_read(socket,data,length);
  258.     if (result==-1) {
  259.         PyErr_SetFromErrno(Error);
  260.         return NULL;
  261.     } else
  262.         return Py_BuildValue("i", result);
  263. }
  264.  
  265. static PyObject *
  266. Write(self, args)
  267.     PyObject *self;
  268.     PyObject *args;
  269. {
  270.     int length,socket, result;
  271.     char * data;
  272.     if (!PyArg_ParseTuple(args, "is#", &socket, &data, &length))
  273.         return NULL;
  274.     result = pi_write(socket,data,length);
  275.     if (result==-1) {
  276.         PyErr_SetFromErrno(Error);
  277.         return NULL;
  278.     } else
  279.         return Py_BuildValue("i", result);
  280. }
  281.  
  282. static PyObject *
  283. Bind(self, args)
  284.     PyObject *self;
  285.     PyObject *args;
  286. {
  287.     PyObject * addr;
  288.     int socket;
  289.     struct pi_sockaddr * a;
  290.     int len,i;
  291.     if (!PyArg_ParseTuple(args, "iO", &socket, &addr))
  292.         return NULL;
  293.     if (PyString_Check(addr)) {
  294.         a = (struct pi_sockaddr *)PyString_AsString(addr);
  295.         len = PyString_Size(addr);
  296.         i = pi_bind(socket,a,len);
  297.     } else if (PyDict_Check(addr)) {
  298.         PyObject * e = PyDict_GetItemString(addr, "device");
  299.         if (e) {
  300.             len = PyString_Size(e)+sizeof(struct pi_sockaddr);
  301.             a = malloc(len);
  302.             strcpy(a->pi_device, PyString_AsString(e));
  303.             
  304.             e = PyDict_GetItemString(addr, "family");
  305.             a->pi_family = e ? PyInt_AsLong(e) : 0;
  306.             e = PyDict_GetItemString(addr, "port");
  307.             a->pi_port = e ? PyInt_AsLong(e) : 0;
  308.             
  309.         }
  310.         i = pi_bind(socket,a,len);
  311.         free(a);
  312.     } else {
  313.         PyErr_SetString(Error, "second argument not string or dict");
  314.         return NULL;
  315.     }
  316.     if (i==-1) {
  317.         PyErr_SetFromErrno(Error);
  318.         return NULL;
  319.     } else
  320.         return Py_BuildValue("i", i);
  321. }
  322.  
  323. static PyObject *
  324. Listen(self, args)
  325.     PyObject *self;
  326.     PyObject *args;
  327. {
  328.     int socket,backlog=1,result;
  329.     if (!PyArg_ParseTuple(args, "i|i", &socket,&backlog))
  330.         return NULL;
  331.     result = pi_listen(socket,backlog);
  332.     if (result==-1) {
  333.         PyErr_SetFromErrno(Error);
  334.         return NULL;
  335.     } else
  336.         return Py_BuildValue("i", result);
  337. }
  338.  
  339. static PyObject *
  340. Accept(self, args)
  341.     PyObject *self;
  342.     PyObject *args;
  343. {
  344.     int socket;
  345.     int result;
  346.     if (!PyArg_ParseTuple(args, "i", &socket))
  347.         return NULL;
  348.     
  349.     result = pi_accept(socket,0,0);
  350.     
  351.     if (result>=0) {
  352.         DlpObject * obj = PyObject_NEW(DlpObject, &Dlp_Type);
  353.         obj->socket = result;
  354.         obj->buffer = malloc(0xffff);
  355.         return (PyObject*)obj;
  356.     } else {
  357.         PyErr_SetFromErrno(Error);
  358.         return NULL;
  359.     }
  360. }
  361.  
  362. static PyObject *
  363. OpenPort(self, args)
  364.     PyObject *self;
  365.     PyObject *args;
  366. {
  367.     char * port;
  368.     PyObject *a, *b, *c;
  369.     if (!PyArg_ParseTuple(args, "s", &port))
  370.         return NULL;
  371.     
  372.     a = Py_BuildValue("(iii)", PI_AF_SLP, PI_SOCK_STREAM, PI_PF_PADP);
  373.     b = Socket(self, a);
  374.     Py_DECREF(a);
  375.     if (!b)
  376.         return NULL;
  377.     a = Py_BuildValue("(O{sisiss})", b, "port", 3, "family", PI_AF_SLP, "device", port);
  378.     c = Bind(self, a);
  379.     Py_DECREF(a);
  380.     if (!c)
  381.         return NULL;
  382.     a = Py_BuildValue("(Oi)", b, 1);
  383.     c = Listen(self, a);
  384.     Py_DECREF(a);
  385.     if (!c)
  386.         return NULL;
  387.     
  388.     return b;
  389. }
  390.  
  391. static int
  392. ParseTm(o, v)
  393.     PyObject * o;
  394.     void *v;
  395. {
  396.     struct tm * t = v;
  397.     
  398.     if (!PyArg_ParseTuple(o, "iiiiiiiii", 
  399.         &t->tm_year, 
  400.         &t->tm_mon,
  401.         &t->tm_mday,
  402.         &t->tm_hour,
  403.         &t->tm_min,
  404.         &t->tm_sec,
  405.         &t->tm_wday,
  406.         &t->tm_yday,
  407.         &t->tm_isdst))
  408.         return 0;
  409.     t->tm_year-=1900;
  410.     t->tm_mon--;
  411.     t->tm_wday = (t->tm_wday+8)%7;
  412.     t->tm_yday--;
  413.     
  414.     return 1;
  415. }
  416.  
  417. static PyObject *
  418. BuildTm(v)
  419.     void *v;
  420. {
  421.     struct tm * t = v;
  422.     
  423.     /* Obey the rules used by Python's timemodule */
  424.     
  425.     return Py_BuildValue("(iiiiiiiii)",
  426.         t->tm_year+1900,
  427.         t->tm_mon+1,
  428.         t->tm_mday,
  429.         t->tm_hour,
  430.         t->tm_min,
  431.         t->tm_sec,
  432.         (t->tm_wday+6)%7,
  433.         t->tm_yday+1,
  434.         t->tm_isdst);
  435. }
  436.  
  437. static int
  438. ParseChar4(o, v)
  439.     PyObject * o;
  440.     void *v;
  441. {
  442.     if (PyString_Check(o)) {
  443.         if (PyString_Size(o) != 4) {
  444.             PyErr_SetString(Error, "code string is not four bytes long");
  445.             return 0;
  446.         }
  447.         *(unsigned long*)v = makelong(PyString_AsString(o));
  448.     } else if (PyInt_Check(o)) {
  449.         *(unsigned long*)v = PyInt_AsLong(o);
  450.     } else {
  451.         PyErr_SetString(Error, "code is not string or int");
  452.         return 0;
  453.     }
  454.     return 1;
  455. }
  456.  
  457. static PyObject *
  458. BuildChar4(v)
  459.     void *v;
  460. {
  461.     char * l = printlong(*(unsigned long*)v);
  462.     if (    (isalpha(l[0]) || (l[0] == ' ')) &&
  463.         (isalpha(l[1]) || (l[1] == ' ')) &&
  464.         (isalpha(l[2]) || (l[2] == ' ')) &&
  465.         (isalpha(l[3]) || (l[3] == ' ')))
  466.         return PyString_FromString(l);
  467.     else
  468.         return PyInt_FromLong(*(unsigned long*)v);
  469. }
  470.  
  471. #define Dlp_CheckError(x)     \
  472.     if ((x)<0) {     \
  473.         PyErr_SetString(Error, dlp_strerror((x)));     \
  474.         return NULL;    \
  475.     } else ;
  476.  
  477. #define DlpDB_CheckError(x)             \
  478.     if ((x)<0) {                 \
  479.         if ((x)==-5) {            \
  480.             Py_INCREF(Py_None);    \
  481.             return Py_None;        \
  482.         } else {            \
  483.             PyErr_SetString(Error, dlp_strerror((x)));     \
  484.             return NULL;        \
  485.         }                \
  486.     } else ;
  487.  
  488. static PyObject *
  489. ResetSystem(self, args)
  490.     DlpObject *self;
  491.     PyObject *args;
  492. {
  493.     int socket, result;
  494.     if (!PyArg_ParseTuple(args, ""))
  495.         return NULL;
  496.     result = dlp_ResetSystem(self->socket);
  497.     Dlp_CheckError(result);
  498.     return Py_BuildValue("i", result);
  499. }
  500.  
  501. static PyObject *
  502. Dirty(self, args)
  503.     DlpObject *self;
  504.     PyObject *args;
  505. {
  506.     int socket, result;
  507.     if (!PyArg_ParseTuple(args, ""))
  508.         return NULL;
  509.     result = dlp_ResetLastSyncPC(self->socket);
  510.     Dlp_CheckError(result);
  511.     return Py_BuildValue("i", result);
  512. }
  513.  
  514. static PyObject *
  515. OpenDB(self, args)
  516.     DlpObject *self;
  517.     PyObject *args;
  518. {
  519.     int mode = dlpOpenReadWrite, cardno = 0;
  520.     char * name;
  521.     int result, handle;
  522.     PyObject * packer;
  523.     DlpDBObject * obj;
  524.     if (!PyArg_ParseTuple(args, "s|ii", &name, &mode, &cardno))
  525.         return NULL;
  526.  
  527.     result = dlp_OpenDB(self->socket, cardno, mode, name, &handle);
  528.     
  529.     Dlp_CheckError(result);
  530.     
  531.     obj = PyObject_NEW(DlpDBObject, &DlpDB_Type);
  532.     obj->socket = self;
  533.     obj->handle = handle;
  534.     Py_INCREF(self);
  535.     
  536.     obj->Pack = obj->Unpack = obj->PackAppBlock = obj->UnpackAppBlock = 0;
  537.     packer = PyDict_GetItemString(DBPackers, name);
  538.     if (packer && PyTuple_Check(packer)) {
  539.         PyArg_ParseTuple(packer, "|OOOO",
  540.             &obj->Pack, &obj->Unpack,
  541.             &obj->PackAppBlock, &obj->UnpackAppBlock);
  542.         Py_XINCREF(obj->Pack);
  543.         Py_XINCREF(obj->Unpack);
  544.         Py_XINCREF(obj->PackAppBlock);
  545.         Py_XINCREF(obj->UnpackAppBlock);
  546.     }
  547.     
  548.     return (PyObject*)obj;
  549. }
  550.  
  551. static PyObject *
  552. CreateDB(self, args)
  553.     DlpObject *self;
  554.     PyObject *args;
  555. {
  556.     char * name;
  557.     long creator, type;
  558.     int cardno=0, flags, version=1;
  559.     int result;
  560.     int handle;
  561.     DlpDBObject * obj;
  562.     PyObject * packer;
  563.     if (!PyArg_ParseTuple(args, "sO&li|ii", &name, &ParseChar4, &creator, &type, &flags, &version, &cardno))
  564.         return NULL;
  565.  
  566.     result = dlp_CreateDB(self->socket, creator, type, cardno, 
  567.         flags, version, name, &handle);
  568.  
  569.     Dlp_CheckError(result);
  570.     
  571.     obj = PyObject_NEW(DlpDBObject, &DlpDB_Type);
  572.     obj->socket = self;
  573.     obj->handle = handle;
  574.     Py_INCREF(self);
  575.  
  576.     obj->Pack = obj->Unpack = obj->PackAppBlock = obj->UnpackAppBlock = 0;
  577.     packer = PyDict_GetItemString(DBPackers, name);
  578.     if (packer && PyTuple_Check(packer)) {
  579.         PyArg_ParseTuple(packer, "|OOOO",
  580.             &obj->Pack, &obj->Unpack,
  581.             &obj->PackAppBlock, &obj->UnpackAppBlock);
  582.         Py_XINCREF(obj->Pack);
  583.         Py_XINCREF(obj->Unpack);
  584.         Py_XINCREF(obj->PackAppBlock);
  585.         Py_XINCREF(obj->UnpackAppBlock);
  586.     }
  587.  
  588.     return (PyObject*)obj;
  589. }
  590.  
  591. static PyObject *
  592. DBUnpack(self, args)
  593.     DlpDBObject *self;
  594.     PyObject *args;
  595. {
  596.     PyObject * incoming;
  597.     
  598.     if (!self->Unpack)
  599.         if (!PyArg_ParseTuple(args, "O", &incoming))
  600.             return NULL;
  601.         else
  602.             return incoming;
  603.     else
  604.         return PyEval_CallObject(self->Unpack, args);
  605. }
  606.  
  607. static PyObject *
  608. DBPack(self, args)
  609.     DlpDBObject *self;
  610.     PyObject *args;
  611. {
  612.     PyObject * incoming;
  613.     
  614.     if (!self->Pack)
  615.         if (!PyArg_ParseTuple(args, "O", &incoming))
  616.             return NULL;
  617.         else
  618.             return incoming;
  619.     else
  620.         return PyEval_CallObject(self->Pack, args);
  621. }
  622.  
  623. static PyObject *
  624. DBPackAppBlock(self, args)
  625.     DlpDBObject *self;
  626.     PyObject *args;
  627. {
  628.     PyObject * incoming;
  629.     
  630.     if (!self->PackAppBlock)
  631.         if (!PyArg_ParseTuple(args, "O", &incoming))
  632.             return NULL;
  633.         else
  634.             return incoming;
  635.     else
  636.         return PyEval_CallObject(self->PackAppBlock, args);
  637. }
  638.  
  639. static PyObject *
  640. DBUnpackAppBlock(self, args)
  641.     DlpDBObject *self;
  642.     PyObject *args;
  643. {
  644.     PyObject * incoming;
  645.     
  646.     if (!self->UnpackAppBlock)
  647.         if (!PyArg_ParseTuple(args, "O", &incoming))
  648.             return NULL;
  649.         else
  650.             return incoming;
  651.     else
  652.         return PyEval_CallObject(self->UnpackAppBlock, args);
  653. }
  654.  
  655. static PyObject *
  656. CloseDB(self, args)
  657.     DlpDBObject *self;
  658.     PyObject *args;
  659. {
  660.     if (!PyArg_ParseTuple(args, ""))
  661.         return NULL;
  662.     
  663.     if (self->handle) {
  664.         int result = dlp_CloseDB(self->socket->socket, self->handle);
  665.         self->handle = 0;        
  666.         Dlp_CheckError(result);
  667.     }
  668.     
  669.     Py_INCREF(Py_None);
  670.     return Py_None;
  671. }
  672.  
  673. static PyObject *
  674. DeleteRsc(self, args)
  675.     DlpDBObject *self;
  676.     PyObject *args;
  677. {
  678.     unsigned long type;
  679.     int id, result;
  680.     
  681.     if (!PyArg_ParseTuple(args, "O&i", &ParseChar4, &type, &id))
  682.         return NULL;
  683.  
  684.     result = dlp_DeleteResource(self->socket->socket, self->handle, 0, type, id);
  685.  
  686.     Dlp_CheckError(result);
  687.  
  688.     return Py_BuildValue("i", result);
  689. }
  690.  
  691. static PyObject *
  692. DeleteAllRsc(self, args)
  693.     DlpDBObject *self;
  694.     PyObject *args;
  695. {
  696.     int result;
  697.     if (!PyArg_ParseTuple(args, ""))
  698.         return NULL;
  699.     
  700.     result = dlp_DeleteResource(self->socket->socket, self->handle, 1, 0, 0);
  701.     
  702.     Dlp_CheckError(result);
  703.     
  704.     return Py_BuildValue("i", result);
  705. }
  706.  
  707. static PyObject *
  708. DeleteRec(self, args)
  709.     DlpDBObject *self;
  710.     PyObject *args;
  711. {
  712.     unsigned long id;
  713.     int result;
  714.     
  715.     if (!PyArg_ParseTuple(args, "l", &id))
  716.         return NULL;
  717.  
  718.     result = dlp_DeleteRecord(self->socket->socket, self->handle, 0, id);
  719.     
  720.     Dlp_CheckError(result);
  721.     
  722.     return Py_BuildValue("i", result);
  723. }
  724.  
  725. static PyObject *
  726. DeleteAllRec(self, args)
  727.     DlpDBObject *self;
  728.     PyObject *args;
  729. {
  730.     int result;
  731.     if (!PyArg_ParseTuple(args, ""))
  732.         return NULL;
  733.         
  734.     result = dlp_DeleteRecord(self->socket->socket, self->handle, 1, 0);
  735.     
  736.     Dlp_CheckError(result);
  737.     
  738.     return Py_BuildValue("i", result);
  739. }
  740.  
  741. static PyObject *
  742. NextModRec(self, args)
  743.     DlpDBObject *self;
  744.     PyObject *args;
  745. {
  746.     unsigned long id;
  747.     int index, length, attr, category=-1;
  748.     int result;
  749.     if (!PyArg_ParseTuple(args, "|i", &category))
  750.         return NULL;
  751.     
  752.     if (category == -1)
  753.         result = dlp_ReadNextModifiedRec(self->socket->socket, self->handle, self->socket->buffer, &id, &index, &length, &attr, &category);
  754.     else
  755.         result = dlp_ReadNextModifiedRecInCategory(self->socket->socket, self->handle, index, self->socket->buffer, &id, &index, &length, &attr);
  756.     
  757.     DlpDB_CheckError(result);
  758.     
  759.     return Py_BuildValue("(s#ilii)", self->socket->buffer, length, index, (long)id, attr, category);
  760. }
  761.  
  762. static PyObject *
  763. NextCatRec(self, args)
  764.     DlpDBObject *self;
  765.     PyObject *args;
  766. {
  767.     unsigned long id;
  768.     int index, length, attr, category;
  769.     int result;
  770.     if (!PyArg_ParseTuple(args, "i", &category))
  771.         return NULL;
  772.     
  773.     result = dlp_ReadNextRecInCategory(self->socket->socket, self->handle, index, self->socket->buffer, &id, &index, &length, &attr);
  774.     
  775.     DlpDB_CheckError(result);
  776.     return Py_BuildValue("(s#ilii)", self->socket->buffer, length, index, (long)id, attr, category);
  777. }
  778.  
  779. static PyObject *
  780. GetRec(self, args)
  781.     DlpDBObject *self;
  782.     PyObject *args;
  783. {
  784.     unsigned long id;
  785.     int index, length, attr, category;
  786.     int result;
  787.     if (!PyArg_ParseTuple(args, "i", &index))
  788.         return NULL;
  789.     
  790.     result = dlp_ReadRecordByIndex(self->socket->socket, self->handle, index, self->socket->buffer, &id, &length, &attr, &category);
  791.     
  792.     DlpDB_CheckError(result);
  793.     
  794.     return Py_BuildValue("(s#ilii)", self->socket->buffer, length, index, (long)id, attr, category);
  795. }
  796.  
  797. static PyObject *
  798. SetRec(self, args)
  799.     DlpDBObject *self;
  800.     PyObject *args;
  801. {
  802.     unsigned long id;
  803.     unsigned long newid;
  804.     int index, length, attr, category;
  805.     char * data;
  806.     int result;
  807.     if (!PyArg_ParseTuple(args, "s#lii", &data, &length, &id, &attr, &category))
  808.         return NULL;
  809.     
  810.     result = dlp_WriteRecord(self->socket->socket, self->handle, attr, id, category, data, length, &newid);
  811.     
  812.     DlpDB_CheckError(result);
  813.     
  814.     return Py_BuildValue("l", (long)newid);
  815. }
  816.  
  817. static PyObject *
  818. SetRsc(self, args)
  819.     DlpDBObject *self;
  820.     PyObject *args;
  821. {
  822.     unsigned long type;
  823.     int id, length;
  824.     char * data;
  825.     int result;
  826.     if (!PyArg_ParseTuple(args, "s#O&i", &data, &length, &ParseChar4, &type, &id))
  827.         return NULL;
  828.     
  829.     result = dlp_WriteResource(self->socket->socket, self->handle, type, id, data, length);
  830.  
  831.     DlpDB_CheckError(result);
  832.     
  833.     return Py_BuildValue("");
  834. }
  835.  
  836. static PyObject *
  837. GetRecById(self, args)
  838.     DlpDBObject *self;
  839.     PyObject *args;
  840. {
  841.     unsigned long id;
  842.     int index, result, length, attr, category;
  843.     if (!PyArg_ParseTuple(args, "l", &id))
  844.         return NULL;
  845.     
  846.     result = dlp_ReadRecordById(self->socket->socket, self->handle, id, self->socket->buffer, &index, &length, &attr, &category);
  847.     
  848.     DlpDB_CheckError(result);
  849.  
  850.     return Py_BuildValue("(s#ilii)", self->socket->buffer, length, index, (long)id, attr, category);
  851. }
  852.  
  853. static PyObject *
  854. GetRsc(self, args)
  855.     DlpDBObject *self;
  856.     PyObject *args;
  857. {
  858.     unsigned long type;
  859.     int id, length, index;
  860.     int result;
  861.     if (!PyArg_ParseTuple(args, "i", &index))
  862.         return NULL;
  863.     
  864.     result = dlp_ReadResourceByIndex(self->socket->socket, self->handle, index, self->socket->buffer, &type, &id, &length);
  865.     
  866.     DlpDB_CheckError(result);
  867.  
  868.     return Py_BuildValue("(s#ili)", self->socket->buffer, length, index, (long)type, id);
  869. }
  870.  
  871. static PyObject *
  872. GetRscById(self, args)
  873.     DlpDBObject *self;
  874.     PyObject *args;
  875. {
  876.     unsigned long type;
  877.     int id, length, index;
  878.     int result;
  879.     if (!PyArg_ParseTuple(args, "O&i", &ParseChar4, &type, &id))
  880.         return NULL;
  881.     
  882.     result = dlp_ReadResourceByType(self->socket->socket, self->handle, type, id, self->socket->buffer, &index, &length);
  883.  
  884.     DlpDB_CheckError(result);    
  885.  
  886.     return Py_BuildValue("(s#ili)", self->socket->buffer, length, index, (long)type, id);
  887. }
  888.  
  889.  
  890. static PyObject *
  891. Records(self, args)
  892.     DlpDBObject *self;
  893.     PyObject *args;
  894. {
  895.     int records, result;
  896.     
  897.     if (!PyArg_ParseTuple(args, ""))
  898.         return NULL;
  899.     
  900.     result = dlp_ReadOpenDBInfo(self->socket->socket, self->handle, &records);
  901.     
  902.     Dlp_CheckError(result);
  903.     
  904.     return Py_BuildValue("i", records);
  905. }
  906.  
  907. static PyObject *
  908. RecordIDs(self, args)
  909.     DlpDBObject *self;
  910.     PyObject *args;
  911. {
  912.     int sort=0, result;
  913.     PyObject *list;
  914.     int count, start;
  915.     int i;
  916.     recordid_t *id = (recordid_t*)self->socket->buffer;
  917.     
  918.     if (!PyArg_ParseTuple(args, "|i"), sort)
  919.         return NULL;
  920.  
  921.     list = PyList_New(0);
  922.     
  923.     start = 0;
  924.     for (;;) {
  925.       result = dlp_ReadRecordIDList(self->socket->socket, self->handle, 
  926.                  sort, start, 0xFFFF/sizeof(recordid_t), id, &count);
  927.       if (result<0) {
  928.         Py_DECREF(list);
  929.         Dlp_CheckError(result);
  930.       } else {
  931.         for(i=0;i<count;i++)
  932.            PyList_Append(list, PyInt_FromLong((long)id[i]));
  933.         if (count == (0xFFFF/sizeof(recordid_t)))
  934.           start = count;
  935.         else
  936.           break;
  937.       }
  938.     }
  939.     
  940.     return list;
  941. }
  942.  
  943. static PyObject *
  944. GetAppBlock(self, args)
  945.     DlpDBObject *self;
  946.     PyObject *args;
  947. {
  948.     int records;
  949.     int length=0xffff,offset=0, result;
  950.     if (!PyArg_ParseTuple(args, "|ii", &length, &offset))
  951.         return NULL;
  952.     
  953.     result = dlp_ReadAppBlock(self->socket->socket, self->handle, offset, self->socket->buffer, length);
  954.     
  955.     Dlp_CheckError(result);
  956.  
  957.     return Py_BuildValue("s#", self->socket->buffer, length);
  958. }
  959.  
  960. static PyObject *
  961. SetAppBlock(self, args)
  962.     DlpDBObject *self;
  963.     PyObject *args;
  964. {
  965.     char * data;
  966.     int length,result;
  967.     if (!PyArg_ParseTuple(args, "s#", &data, &length));
  968.         return NULL;
  969.     
  970.     result = dlp_WriteAppBlock(self->socket->socket, self->handle, data, length);
  971.     
  972.     Dlp_CheckError(result);
  973.     
  974.     return Py_BuildValue("i", result);
  975. }
  976.  
  977. static PyObject *
  978. GetSortBlock(self, args)
  979.     DlpDBObject *self;
  980.     PyObject *args;
  981. {
  982.     int records;
  983.     int length=0xffff,offset=0, result;
  984.     if (!PyArg_ParseTuple(args, "|ii", &length, &offset))
  985.         return NULL;
  986.     
  987.     result = dlp_ReadSortBlock(self->socket->socket, self->handle, offset, self->socket->buffer, length);
  988.     
  989.     Dlp_CheckError(result);
  990.     
  991.     return Py_BuildValue("s#", self->socket->buffer, length);
  992. }
  993.  
  994. static PyObject *
  995. SetSortBlock(self, args)
  996.     DlpDBObject *self;
  997.     PyObject *args;
  998. {
  999.     char * data;
  1000.     int length, result;
  1001.     if (!PyArg_ParseTuple(args, "s#", &data, &length));
  1002.         return NULL;
  1003.     
  1004.     result = dlp_WriteSortBlock(self->socket->socket, self->handle, data, length);
  1005.     
  1006.     Dlp_CheckError(result);
  1007.     
  1008.     return Py_BuildValue("i", result);
  1009. }
  1010.  
  1011. static PyObject *
  1012. MoveCategory(self, args)
  1013.     DlpDBObject *self;
  1014.     PyObject *args;
  1015. {
  1016.     int from,to, result;
  1017.     if (!PyArg_ParseTuple(args, "ii", &from, &to))
  1018.         return NULL;
  1019.     
  1020.     result = dlp_MoveCategory(self->socket->socket, self->handle, from, to);
  1021.  
  1022.     Dlp_CheckError(result);
  1023.     
  1024.     return Py_BuildValue("i", result);
  1025. }
  1026.  
  1027. static PyObject *
  1028. DeleteCategory(self, args)
  1029.     DlpDBObject *self;
  1030.     PyObject *args;
  1031. {
  1032.     int category, result;
  1033.     if (!PyArg_ParseTuple(args, "i", &category))
  1034.         return NULL;
  1035.     
  1036.     result = dlp_DeleteCategory(self->socket->socket, self->handle, category);
  1037.  
  1038.     Dlp_CheckError(result);
  1039.     
  1040.     return Py_BuildValue("i", result);
  1041. }
  1042.  
  1043. static PyObject *
  1044. Purge(self, args)
  1045.     DlpDBObject *self;
  1046.     PyObject *args;
  1047. {
  1048.     int result;
  1049.     if (!PyArg_ParseTuple(args, ""))
  1050.         return NULL;
  1051.     
  1052.     result = dlp_CleanUpDatabase(self->socket->socket, self->handle);
  1053.     
  1054.     Dlp_CheckError(result);
  1055.     
  1056.     return Py_BuildValue("i", result);
  1057. }
  1058.  
  1059. static PyObject *
  1060. ResetNext(self, args)
  1061.     DlpDBObject *self;
  1062.     PyObject *args;
  1063. {
  1064.     int result;
  1065.     if (!PyArg_ParseTuple(args, ""))
  1066.         return NULL;
  1067.     
  1068.     result = dlp_ResetDBIndex(self->socket->socket, self->handle);
  1069.     
  1070.     Dlp_CheckError(result);
  1071.     
  1072.     return Py_BuildValue("i", result);
  1073. }
  1074.  
  1075. static PyObject *
  1076. ResetFlags(self, args)
  1077.     DlpDBObject *self;
  1078.     PyObject *args;
  1079. {
  1080.     int result;
  1081.     if (!PyArg_ParseTuple(args, ""))
  1082.         return NULL;
  1083.         
  1084.     result = dlp_ResetSyncFlags(self->socket->socket, self->handle);
  1085.  
  1086.     Dlp_CheckError(result);
  1087.     
  1088.     return Py_BuildValue("i", result);
  1089. }
  1090.  
  1091. static PyObject *
  1092. Close(self, args)
  1093.     DlpObject *self;
  1094.     PyObject *args;
  1095. {
  1096.     int status = 0;
  1097.     int result;
  1098.     if (!PyArg_ParseTuple(args, "|i", &status))
  1099.         return NULL;
  1100.     
  1101.     if (self->socket) {
  1102.         if (status) {
  1103.             result = dlp_EndOfSync(self->socket, status);
  1104.             Dlp_CheckError(result);
  1105.         }
  1106.         result = pi_close(self->socket);
  1107.         self->socket = 0;
  1108.         if (result == -1) {
  1109.             PyErr_SetFromErrno(Error);
  1110.             return NULL;
  1111.         }
  1112.     }
  1113.     
  1114.     Py_INCREF(Py_None);
  1115.     return Py_None;
  1116. }
  1117.  
  1118. static PyObject *
  1119. Abort(self, args)
  1120.     DlpObject *self;
  1121.     PyObject *args;
  1122. {
  1123.     int result;
  1124.     if (!PyArg_ParseTuple(args, ""))
  1125.         return NULL;
  1126.     
  1127.     if (self->socket) {
  1128.         result = dlp_AbortSync(self->socket);
  1129.         Dlp_CheckError(result);
  1130.         result = pi_close(self->socket);
  1131.         self->socket = 0;
  1132.         if (result == -1) {
  1133.             PyErr_SetFromErrno(Error);
  1134.             return NULL;
  1135.         }
  1136.     }
  1137.  
  1138.     return Py_BuildValue("");
  1139. }
  1140.  
  1141. static PyObject *
  1142. GetAppPref(self, args)
  1143.     DlpObject *self;
  1144.     PyObject *args;
  1145. {
  1146.     unsigned long creator;
  1147.     int id, backup=1;
  1148.     int length, version, result;
  1149.     
  1150.     if (!PyArg_ParseTuple(args, "O&i|i", &ParseChar4, &creator, &id, &backup))
  1151.         return NULL;
  1152.  
  1153.     result = dlp_ReadAppPreference(self->socket, creator, id, backup,
  1154.         0xffff, self->buffer, &length, &version);
  1155.     
  1156.     Dlp_CheckError(result);
  1157.     
  1158.     return Py_BuildValue("(s#O&ii)", self->buffer, length, &BuildChar4, creator, id, version);
  1159. }
  1160.  
  1161. static PyObject *
  1162. SetAppPref(self, args)
  1163.     DlpObject *self;
  1164.     PyObject *args;
  1165. {
  1166.     unsigned long creator;
  1167.     int id, length, version, backup, result;
  1168.     char * data;
  1169.  
  1170.     if (!PyArg_ParseTuple(args, "s#O&iii", &data, &length, &ParseChar4, &creator, &id, &version, &backup))
  1171.         return NULL;
  1172.  
  1173.     result = dlp_WriteAppPreference(self->socket, creator, id, backup,
  1174.         version, data, length);
  1175.         
  1176.     Dlp_CheckError(result);
  1177.  
  1178.     return Py_BuildValue("i", result);
  1179. }
  1180.  
  1181. static PyObject *
  1182. DeleteDB(self, args)
  1183.     DlpObject *self;
  1184.     PyObject *args;
  1185. {
  1186.     char * name;
  1187.     int cardno = 0;
  1188.     int result;
  1189.     if (!PyArg_ParseTuple(args, "s|i", &name, &cardno))
  1190.         return NULL;
  1191.  
  1192.     result = dlp_DeleteDB(self->socket, cardno, name);
  1193.     
  1194.     Dlp_CheckError(result);
  1195.  
  1196.     return Py_BuildValue("i", result);
  1197. }
  1198.  
  1199. static PyObject *
  1200. Status(self, args)
  1201.     DlpObject *self;
  1202.     PyObject *args;
  1203. {
  1204.     int result;
  1205.     if (!PyArg_ParseTuple(args, ""))
  1206.         return NULL;
  1207.     
  1208.     result = dlp_OpenConduit(self->socket);
  1209.     
  1210.     Dlp_CheckError(result);
  1211.  
  1212.     return Py_BuildValue("i", result);
  1213. }
  1214.  
  1215. static PyObject *
  1216. Battery(self, args)
  1217.     DlpObject *self;
  1218.     PyObject *args;
  1219. {
  1220.     int warn, critical, ticks, kind, AC;
  1221.     unsigned long voltage;
  1222.     int result;
  1223.     struct RPC_params p;
  1224.     if (!PyArg_ParseTuple(args, ""))
  1225.         return NULL;
  1226.  
  1227.     PackRPC(&p,0xA0B6, RPC_IntReply,
  1228.         RPC_Byte(0), RPC_ShortPtr(&warn), RPC_ShortPtr(&critical),
  1229.         RPC_ShortPtr(&ticks), RPC_BytePtr(&kind), RPC_BytePtr(&AC), RPC_End);
  1230.     
  1231.     result = dlp_RPC(self->socket, &p, &voltage);
  1232.     
  1233.     return Py_BuildValue("(fffii)", (float)voltage/100, 
  1234.         (float)warn/100, (float)critical/100, kind, AC);
  1235. }
  1236.  
  1237. static PyObject *
  1238. GetTime(self, args)
  1239.     DlpObject *self;
  1240.     PyObject *args;
  1241. {
  1242.     unsigned long time;
  1243.     int result;
  1244.     if (!PyArg_ParseTuple(args, ""))
  1245.         return NULL;
  1246.         
  1247.     result = dlp_GetSysDateTime(self->socket, &time);
  1248.     
  1249.     Dlp_CheckError(result);
  1250.  
  1251.     return Py_BuildValue("l", (long)time);
  1252. }
  1253.  
  1254. static PyObject *
  1255. GetFeature(self, args)
  1256.     DlpObject *self;
  1257.     PyObject *args;
  1258. {
  1259.     unsigned long creator, feature;
  1260.     int result, number;
  1261.     if (!PyArg_ParseTuple(args, "O&i"), &ParseChar4, &creator, &number)
  1262.         return NULL;
  1263.         
  1264.     result = dlp_ReadFeature(self->socket, creator, number, &feature);
  1265.     
  1266.     Dlp_CheckError(result);
  1267.  
  1268.     return Py_BuildValue("l", (long)feature);
  1269. }
  1270.  
  1271. static PyObject *
  1272. CallApp(self, args)
  1273.     DlpObject *self;
  1274.     PyObject *args;
  1275. {
  1276.     unsigned long creator, type;
  1277.     int action, length = 0;
  1278.     char * data = 0;
  1279.     int result;
  1280.     unsigned long retcode;
  1281.     int maxlength=0xffff;
  1282.     if (!PyArg_ParseTuple(args, "O&O&i|s#l", &ParseChar4, &creator, &ParseChar4, &type, &action, &data, &length, &maxlength))
  1283.         return NULL;
  1284.     
  1285.     result = dlp_CallApplication(self->socket, creator, type, action, 
  1286.         length, data, &retcode, maxlength, &length, self->buffer);
  1287.     
  1288.     Dlp_CheckError(result);
  1289.     
  1290.     return Py_BuildValue("ls#", (long)retcode, self->buffer, length);
  1291. }
  1292.  
  1293. static PyObject *
  1294. Log(self, args)
  1295.     DlpObject *self;
  1296.     PyObject *args;
  1297. {
  1298.     char * string;
  1299.     int result;
  1300.     if (!PyArg_ParseTuple(args, "s", &string))
  1301.         return NULL;
  1302.     
  1303.     result = dlp_AddSyncLogEntry(self->socket, string);
  1304.  
  1305.     Dlp_CheckError(result);
  1306.  
  1307.     return Py_BuildValue("i", result);
  1308. }
  1309.  
  1310. static PyObject *
  1311. CardInfo(self, args)
  1312.     DlpObject *self;
  1313.     PyObject *args;
  1314. {
  1315.     int cardno=0;
  1316.     int result;
  1317.     struct CardInfo s;
  1318.     if (!PyArg_ParseTuple(args, "|i", &cardno))
  1319.         return NULL;
  1320.  
  1321.     result = dlp_ReadStorageInfo(self->socket, cardno, &s);
  1322.     
  1323.     Dlp_CheckError(result);
  1324.     
  1325.     return Py_BuildValue("{sisislslslslssss}",
  1326.         "cardno", s.cardno,
  1327.         "version", s.version,
  1328.         "created", (long)s.creation,
  1329.         "ROMsize", (long)s.ROMsize,
  1330.         "RAMsize", (long)s.RAMsize,
  1331.         "RAMfree", (long)s.RAMfree,
  1332.         "name", s.name,
  1333.         "manufacturer", s.manuf);
  1334. }
  1335.  
  1336. static PyObject *
  1337. GetUserInfo(self, args)
  1338.     DlpObject *self;
  1339.     PyObject *args;
  1340. {
  1341.     int result;
  1342.     struct PilotUser p;
  1343.     if (!PyArg_ParseTuple(args, ""))
  1344.         return NULL;
  1345.  
  1346.     result = dlp_ReadUserInfo(self->socket, &p);
  1347.     
  1348.     Dlp_CheckError(result);
  1349.     
  1350.     return Py_BuildValue("{slslssslslslss#}",
  1351.         "userID", (long)p.userID,
  1352.         "viewerID", (long)p.viewerID,
  1353.         "name", p.username,
  1354.         "lastSyncPC", (long)p.lastSyncPC,
  1355.         "lastGoodSync", (long)p.succSyncDate,
  1356.         "lastSync", (long)p.lastSyncDate,
  1357.         "password", p.password, p.passwordLen
  1358.         );
  1359. }
  1360.  
  1361.  
  1362. static PyObject *
  1363. BuildDBInfo(i)
  1364.     struct DBInfo * i;
  1365. {
  1366.     return Py_BuildValue("{sisisisOsOsisislslslslss}",
  1367.         "more", i->more,
  1368.         "flags", i->flags,
  1369.         "miscflags", i->miscflags,
  1370.         "type", BuildChar4(&i->type),
  1371.         "creator", BuildChar4(&i->creator),
  1372.         "version", i->version,
  1373.         "index", i->index,
  1374.         "modnum", (long)i->modnum,
  1375.         "crdate", (long)i->crdate,
  1376.         "moddate", (long)i->moddate,
  1377.         "backupdate", (long)i->backupdate,
  1378.         "name", i->name
  1379.         );
  1380. }
  1381.  
  1382. static int ParseDBInfo(d, i)
  1383.     PyObject * d;
  1384.     struct DBInfo * i;
  1385. {
  1386.     PyObject * e;
  1387.     
  1388.     memset(i, '\0', sizeof(struct DBInfo));
  1389.     
  1390.     i->flags = (e=PyDict_GetItemString(d, "flags")) ? PyInt_AsLong(e) : 0;
  1391.     i->miscflags = (e=PyDict_GetItemString(d, "miscflags")) ? PyInt_AsLong(e) : 0;
  1392.     e=PyDict_GetItemString(d, "type");
  1393.     if (e) {
  1394.         if (ParseChar4(e, &i->type)==0)
  1395.             return 0;
  1396.     } else
  1397.         i->type = 0;
  1398.     e=PyDict_GetItemString(d, "creator");
  1399.     if (e) {
  1400.         if (ParseChar4(e, &i->creator)==0)
  1401.             return 0;
  1402.     } else
  1403.         i->creator = 0;
  1404.     i->more = (e=PyDict_GetItemString(d, "more")) ? PyInt_AsLong(e) : 0;
  1405.     i->version = (e=PyDict_GetItemString(d, "version")) ? PyInt_AsLong(e) : 0;
  1406.     i->modnum = (e=PyDict_GetItemString(d, "modnum")) ? PyInt_AsLong(e) : 0;
  1407.     i->index = (e=PyDict_GetItemString(d, "index")) ? PyInt_AsLong(e) : 0;
  1408.     i->crdate = (e=PyDict_GetItemString(d, "crdate")) ? PyInt_AsLong(e) : 0;
  1409.     i->moddate = (e=PyDict_GetItemString(d, "moddate")) ? PyInt_AsLong(e) : 0;
  1410.     i->backupdate = (e=PyDict_GetItemString(d, "backupdate")) ? PyInt_AsLong(e) : 0;
  1411.     strcpy(i->name, (e=PyDict_GetItemString(d, "name")) ? PyString_AsString(e) : "");
  1412.     
  1413.     return 1;
  1414. }
  1415.     
  1416.  
  1417. static PyObject *
  1418. SetUserInfo(self, args)
  1419.     DlpObject *self;
  1420.     PyObject *args;
  1421. {
  1422.     int result;
  1423.     PyObject * d, *e;
  1424.     struct PilotUser p;
  1425.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &d))
  1426.         return NULL;
  1427.     
  1428.     if (!PyDict_Check(d))
  1429.         return NULL;
  1430.         
  1431.     memset(&p, '\0', sizeof(struct PilotUser));
  1432.     
  1433.     p.userID = (e=PyDict_GetItemString(d, "userID")) ? PyInt_AsLong(e) : 0;
  1434.     p.viewerID = (e=PyDict_GetItemString(d, "viewerID")) ? PyInt_AsLong(e) : 0;
  1435.     p.lastSyncPC = (e=PyDict_GetItemString(d, "lastSyncPC")) ? PyInt_AsLong(e) : 0;
  1436.     p.succSyncDate = (e=PyDict_GetItemString(d, "lastGoodSync")) ? PyInt_AsLong(e) : 0;
  1437.     p.lastSyncDate = (e=PyDict_GetItemString(d, "lastSync")) ? PyInt_AsLong(e) : 0;
  1438.     strcpy(p.username, (e=PyDict_GetItemString(d, "name")) ? PyString_AsString(e) : "");
  1439.  
  1440.     result = dlp_WriteUserInfo(self->socket, &p);
  1441.     
  1442.     Dlp_CheckError(result);
  1443.     
  1444.     return Py_BuildValue(""); /* None */
  1445. }
  1446.  
  1447. static PyObject *
  1448. SysInfo(self, args)
  1449.     DlpObject *self;
  1450.     PyObject *args;
  1451. {
  1452.     int result;
  1453.     struct SysInfo s;
  1454.     if (!PyArg_ParseTuple(args, ""))
  1455.         return NULL;
  1456.  
  1457.     result = dlp_ReadSysInfo(self->socket, &s);
  1458.     
  1459.     Dlp_CheckError(result);
  1460.     
  1461.     return Py_BuildValue("{slslss}",
  1462.         "ROMversion", (long)s.ROMVersion,
  1463.         "localizationID", (long)s.localizationID,
  1464.         "name", s.name);
  1465. }
  1466.  
  1467. static PyObject *
  1468. GetDBInfo(self, args)
  1469.     DlpObject *self;
  1470.     PyObject *args;
  1471. {
  1472.     int result;
  1473.     int db, where, cardno=0;
  1474.     struct DBInfo i;
  1475.     
  1476.     if (!PyArg_ParseTuple(args, "ii|i", &db, &where, &cardno))
  1477.         return NULL;
  1478.  
  1479.     result = dlp_ReadDBList(self->socket, cardno, where, db, &i);
  1480.     
  1481.     if (result == -5) {
  1482.         return Py_BuildValue(""); 
  1483.     }
  1484.     
  1485.     Dlp_CheckError(result);
  1486.     
  1487.     return BuildDBInfo(&i);
  1488. }
  1489.  
  1490. static PyObject *
  1491. FindDBInfo(self, args)
  1492.     DlpObject *self;
  1493.     PyObject *args;
  1494. {
  1495.     int result;
  1496.     int db, cardno=0;
  1497.     char * name;
  1498.     PyObject *creator, *type;
  1499.     unsigned long cl, tl;
  1500.     struct DBInfo i;
  1501.     
  1502.     if (!PyArg_ParseTuple(args, "izOO|i", &db, &name, &creator, &type, &cardno))
  1503.         return NULL;
  1504.  
  1505.     if (creator == Py_None)
  1506.         cl = 0;
  1507.     else
  1508.         if (ParseChar4(creator, &cl) == 0)
  1509.             return NULL;
  1510.  
  1511.     if (type == Py_None)
  1512.         tl = 0;
  1513.     else
  1514.         if (ParseChar4(type, &tl) == 0)
  1515.             return NULL;
  1516.  
  1517.     result = dlp_FindDBInfo(self->socket, cardno, db, name, tl, cl, &i);
  1518.     
  1519.     Dlp_CheckError(result);
  1520.     
  1521.     return BuildDBInfo(&i);
  1522. }
  1523.  
  1524. static PyObject *
  1525. SetTime(self, args)
  1526.     DlpObject *self;
  1527.     PyObject *args;
  1528. {
  1529.     unsigned long time;
  1530.     int result;
  1531.     if (!PyArg_ParseTuple(args, "l", &time))
  1532.         return NULL;
  1533.     
  1534.     result = dlp_SetSysDateTime(self->socket, time);
  1535.     
  1536.     Dlp_CheckError(result);
  1537.  
  1538.     return Py_BuildValue("l", (long)time);
  1539. }
  1540.  
  1541. static PyObject *
  1542. OpenFile(self, args)
  1543.     PyObject *self;
  1544.     PyObject *args;
  1545. {
  1546.     char * name;
  1547.     struct pi_file * pf;
  1548.     PiFileObject * retval;
  1549.     PyObject * packer;
  1550.     if (!PyArg_ParseTuple(args, "s", &name))
  1551.         return NULL;
  1552.  
  1553.     pf = pi_file_open(name);
  1554.     if (!pf) {
  1555.         PyErr_SetString(Error, "Unable to open file");
  1556.         return NULL;
  1557.     }
  1558.     
  1559.     retval = PyObject_NEW(PiFileObject, &PiFile_Type);
  1560.     retval->pf = pf;
  1561.  
  1562.     retval->Pack = retval->Unpack = retval->PackAppBlock = retval->UnpackAppBlock = 0;
  1563.     packer = PyDict_GetItemString(DBPackers, name);
  1564.     if (packer && PyTuple_Check(packer)) {
  1565.         PyArg_ParseTuple(packer, "|OOOO",
  1566.             &retval->Pack, &retval->Unpack,
  1567.             &retval->PackAppBlock, &retval->UnpackAppBlock);
  1568.         Py_XINCREF(retval->Pack);
  1569.         Py_XINCREF(retval->Unpack);
  1570.         Py_XINCREF(retval->PackAppBlock);
  1571.         Py_XINCREF(retval->UnpackAppBlock);
  1572.     }
  1573.  
  1574.     return (PyObject*)retval;
  1575. }
  1576.  
  1577.  
  1578. static PyObject *
  1579. CreateFile(self, args)
  1580.     PyObject *self;
  1581.     PyObject *args;
  1582. {
  1583.     char * name;
  1584.     struct pi_file * pf;
  1585.     struct DBInfo i;
  1586.     PiFileObject * retval;
  1587.     PyObject * d, *packer;
  1588.     if (!PyArg_ParseTuple(args, "sO!", &name, &PyDict_Type, &d))
  1589.         return NULL;
  1590.     
  1591.     if (ParseDBInfo(d, &i)==0)
  1592.         return NULL;
  1593.  
  1594.     pf = pi_file_create(name, &i);
  1595.     if (!pf) {
  1596.         PyErr_SetString(Error, "Unable to create file");
  1597.         return NULL;
  1598.     }
  1599.     
  1600.     retval = PyObject_NEW(PiFileObject, &PiFile_Type);
  1601.     retval->pf = pf;
  1602.  
  1603.     retval->Pack = retval->Unpack = retval->PackAppBlock = retval->UnpackAppBlock = 0;
  1604.     packer = PyDict_GetItemString(DBPackers, name);
  1605.     if (packer && PyTuple_Check(packer)) {
  1606.         PyArg_ParseTuple(packer, "|OOOO",
  1607.             &retval->Pack, &retval->Unpack,
  1608.             &retval->PackAppBlock, &retval->UnpackAppBlock);
  1609.         Py_XINCREF(retval->Pack);
  1610.         Py_XINCREF(retval->Unpack);
  1611.         Py_XINCREF(retval->PackAppBlock);
  1612.         Py_XINCREF(retval->UnpackAppBlock);
  1613.     }
  1614.  
  1615.  
  1616.     return (PyObject*)retval;
  1617. }
  1618.  
  1619. static PyObject *
  1620. FileClose(self, args)
  1621.     PiFileObject *self;
  1622.     PyObject *args;
  1623. {
  1624.     if (!PyArg_ParseTuple(args, ""))
  1625.         return NULL;
  1626.         
  1627.     pi_file_close(self->pf);
  1628.     self->pf = 0;
  1629.  
  1630.     return Py_BuildValue("");
  1631. }
  1632.  
  1633. static PyObject *
  1634. FileRecords(self, args)
  1635.     PiFileObject *self;
  1636.     PyObject *args;
  1637. {
  1638.     int records;
  1639.     
  1640.     if (!PyArg_ParseTuple(args, ""))
  1641.         return NULL;
  1642.         
  1643.     if (pi_file_get_entries(self->pf, &records)==-1)
  1644.         return Py_BuildValue("");
  1645.     else
  1646.         return Py_BuildValue("i", records);
  1647. }
  1648.  
  1649. static PyObject *
  1650. FileCheckID(self, args)
  1651.     PiFileObject *self;
  1652.     PyObject *args;
  1653. {
  1654.     int records;
  1655.     unsigned long id;
  1656.     
  1657.     if (!PyArg_ParseTuple(args, "l", id))
  1658.         return NULL;
  1659.         
  1660.     return Py_BuildValue("i", pi_file_id_used(self->pf, id));
  1661. }
  1662.  
  1663. static PyObject *
  1664. FileGetRec(self, args)
  1665.     PiFileObject *self;
  1666.     PyObject *args;
  1667. {
  1668.     int index, attr, category;
  1669.     void * c;
  1670.     int length;
  1671.     unsigned long id;
  1672.     if (!PyArg_ParseTuple(args, "i", &index))
  1673.         return NULL;
  1674.     
  1675.     if (pi_file_read_record(self->pf, index, &c, &length, &attr, &category, &id)==-1)
  1676.         return Py_BuildValue("");
  1677.     else
  1678.         return Py_BuildValue("(s#ilii)", c, length, index, (long)id, attr, category);
  1679. }
  1680.  
  1681. static PyObject *
  1682. FileGetRecById(self, args)
  1683.     PiFileObject *self;
  1684.     PyObject *args;
  1685. {
  1686.     int index, attr, category;
  1687.     void * c;
  1688.     int length;
  1689.     unsigned long id;
  1690.     if (!PyArg_ParseTuple(args, "l", &id))
  1691.         return NULL;
  1692.     
  1693.     if (pi_file_read_record_by_id(self->pf, id, &c, &length, &index, &attr, &category)==-1)
  1694.         return Py_BuildValue("");
  1695.     else
  1696.         return Py_BuildValue("(s#ilii)", c, length, index, (long)id, attr, category);
  1697. }
  1698.  
  1699. static PyObject *
  1700. FileGetDBInfo(self, args)
  1701.     PiFileObject *self;
  1702.     PyObject *args;
  1703. {
  1704.     struct DBInfo i;
  1705.     if (!PyArg_ParseTuple(args, ""))
  1706.         return NULL;
  1707.     
  1708.     if (pi_file_get_info(self->pf, &i)==-1) {
  1709.         PyErr_SetFromErrno(Error);
  1710.         return NULL;
  1711.     } else
  1712.         return BuildDBInfo(&i);
  1713. }
  1714.  
  1715. static PyObject *
  1716. FileSetDBInfo(self, args)
  1717.     PiFileObject *self;
  1718.     PyObject *args;
  1719. {
  1720.     PyObject *o;
  1721.     struct DBInfo i;
  1722.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &o))
  1723.         return NULL;
  1724.     
  1725.     if (ParseDBInfo(o, &i)==0)
  1726.         return NULL;
  1727.     
  1728.     if (pi_file_set_info(self->pf, &i)==-1) {
  1729.         PyErr_SetFromErrno(Error);
  1730.         return NULL;
  1731.     } else
  1732.         return Py_BuildValue("");
  1733. }
  1734.  
  1735.  
  1736.  
  1737. static PyObject *
  1738. FileGetAppBlock(self, args)
  1739.     PiFileObject *self;
  1740.     PyObject *args;
  1741. {
  1742.     void * c;
  1743.     int length;
  1744.     if (!PyArg_ParseTuple(args, ""))
  1745.         return NULL;
  1746.     
  1747.     if (pi_file_get_app_info(self->pf, &c, &length)==-1) {
  1748.         PyErr_SetFromErrno(Error);
  1749.         return NULL;
  1750.     } else
  1751.         return Py_BuildValue("s#", c, length);
  1752. }
  1753.  
  1754. static PyObject *
  1755. FileSetAppBlock(self, args)
  1756.     PiFileObject *self;
  1757.     PyObject *args;
  1758. {
  1759.     char * c;
  1760.     int length;
  1761.     if (!PyArg_ParseTuple(args, "s#", &c, &length))
  1762.         return NULL;
  1763.     
  1764.     if (pi_file_set_app_info(self->pf, c, length)==-1) {
  1765.         PyErr_SetFromErrno(Error);
  1766.         return NULL;
  1767.     } else
  1768.         return Py_BuildValue("");
  1769. }
  1770.  
  1771. static PyObject *
  1772. FileGetSortBlock(self, args)
  1773.     PiFileObject *self;
  1774.     PyObject *args;
  1775. {
  1776.     void * c;
  1777.     int length;
  1778.     if (!PyArg_ParseTuple(args, ""))
  1779.         return NULL;
  1780.     
  1781.     if (pi_file_get_sort_info(self->pf, &c, &length)==-1) {
  1782.         PyErr_SetFromErrno(Error);
  1783.         return NULL;
  1784.     } else
  1785.         return Py_BuildValue("s#", c, length);
  1786. }
  1787.  
  1788. static PyObject *
  1789. FileSetSortBlock(self, args)
  1790.     PiFileObject *self;
  1791.     PyObject *args;
  1792. {
  1793.     char * c;
  1794.     int length;
  1795.     if (!PyArg_ParseTuple(args, "s#", &c, &length))
  1796.         return NULL;
  1797.     
  1798.     if (pi_file_set_sort_info(self->pf, c, length)==-1) {
  1799.         PyErr_SetFromErrno(Error);
  1800.         return NULL;
  1801.     } else
  1802.         return Py_BuildValue("");
  1803. }
  1804.  
  1805. static PyObject *
  1806. FileGetRsc(self, args)
  1807.     PiFileObject *self;
  1808.     PyObject *args;
  1809. {
  1810.     int index, id;
  1811.     void * c;
  1812.     int length;
  1813.     unsigned long type;
  1814.     if (!PyArg_ParseTuple(args, "i", &index))
  1815.         return NULL;
  1816.     
  1817.     if (pi_file_read_resource(self->pf, index, &c, &length, &type, &id)==-1)
  1818.         return Py_BuildValue("");
  1819.     else
  1820.         return Py_BuildValue("(s#ili)", c, length, index, (long)type, id);
  1821. }
  1822.  
  1823. static PyObject *
  1824. FileAddRec(self, args)
  1825.     PiFileObject *self;
  1826.     PyObject *args;
  1827. {
  1828.     unsigned long id;
  1829.     unsigned long newid;
  1830.     int length, attr, category;
  1831.     char * data;
  1832.     int result;
  1833.     if (!PyArg_ParseTuple(args, "s#lii", &data, &length, &id, &attr, &category))
  1834.         return NULL;
  1835.     
  1836.     if (pi_file_append_record(self->pf, data, length, attr, category, id)==-1) {
  1837.         PyErr_SetFromErrno(Error);
  1838.         return NULL;
  1839.     } 
  1840.     
  1841.     return Py_BuildValue("l", (long)id);
  1842. }
  1843.  
  1844. static PyObject *
  1845. FileAddRsc(self, args)
  1846.     PiFileObject *self;
  1847.     PyObject *args;
  1848. {
  1849.     unsigned long type;
  1850.     int id, length;
  1851.     char * data;
  1852.     int result;
  1853.     if (!PyArg_ParseTuple(args, "s#lii", &data, &length, &type, &id))
  1854.         return NULL;
  1855.     
  1856.     if (pi_file_append_resource(self->pf, data, length, type, id)==-1) {
  1857.         PyErr_SetFromErrno(Error);
  1858.         return NULL;
  1859.     }
  1860.  
  1861.     return Py_BuildValue("");
  1862. }
  1863.  
  1864. static PyObject *
  1865. FileInstall(self, args)
  1866.     PiFileObject *self;
  1867.     PyObject *args;
  1868. {
  1869.     DlpObject *socket;
  1870.     int result;
  1871.     int cardno=0;
  1872.     if (!PyArg_ParseTuple(args, "O!|i", &Dlp_Type, &socket, &cardno))
  1873.         return NULL;
  1874.     
  1875.     if (pi_file_install(self->pf, socket->socket, cardno)==-1) {
  1876.         PyErr_SetFromErrno(Error);
  1877.         return NULL;
  1878.     }
  1879.  
  1880.     return Py_BuildValue("");
  1881. }
  1882.  
  1883. static PyObject *
  1884. FileRetrieve(self, args)
  1885.     PiFileObject *self;
  1886.     PyObject *args;
  1887. {
  1888.     DlpObject *socket;
  1889.     int result;
  1890.     int cardno=0;
  1891.     if (!PyArg_ParseTuple(args, "O!|i", &Dlp_Type, &socket, &cardno))
  1892.         return NULL;
  1893.     
  1894.     if (pi_file_retrieve(self->pf, socket->socket, cardno)==-1) {
  1895.         PyErr_SetFromErrno(Error);
  1896.         return NULL;
  1897.     }
  1898.  
  1899.     return Py_BuildValue("");
  1900. }
  1901.  
  1902. static PyObject *
  1903. MemoUnpack(self, args)
  1904.     PyObject *self;
  1905.     PyObject *args;
  1906. {
  1907.     char * data;
  1908.     int length;
  1909.     struct Memo m;
  1910.     PyObject * result;
  1911.     
  1912.     if (!PyArg_ParseTuple(args, "s#", &data, &length))
  1913.         return NULL;
  1914.     
  1915.     unpack_Memo(&m, data, length);
  1916.     
  1917.     result = Py_BuildValue("{ss}", "text", m.text);
  1918.     
  1919.     free_Memo(&m);
  1920.     
  1921.     return result;
  1922. }
  1923.  
  1924. static PyObject *
  1925. MemoPack(self, args)
  1926.     PyObject *self;
  1927.     PyObject *args;
  1928. {
  1929.     char * data;
  1930.     int length;
  1931.     struct Memo m;
  1932.     PyObject * o, *e;
  1933.     
  1934.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &o))
  1935.         return NULL;
  1936.     
  1937.     data = malloc(0xffff);
  1938.     
  1939.     m.text = (e=PyDict_GetItemString(o, "text")) ? PyString_AsString(e) : 0;
  1940.     
  1941.     pack_Memo(&m, data, &length);
  1942.     
  1943.     o = Py_BuildValue("s#", data, length);
  1944.     free(data);
  1945.     
  1946.     return o;
  1947. }
  1948.  
  1949. static PyObject *
  1950. MemoUnpackAppBlock(self, args)
  1951.     PyObject *self;
  1952.     PyObject *args;
  1953. {
  1954.     char * data;
  1955.     int length;
  1956.     PyObject *names, *ids;
  1957.     struct MemoAppInfo m;
  1958.     int i;
  1959.     
  1960.     if (!PyArg_ParseTuple(args, "s#", &data, &length))
  1961.         return NULL;
  1962.     
  1963.     unpack_MemoAppInfo(&m, data, length);
  1964.     
  1965.     names = PyList_New(16);
  1966.     for (i=0;i<16;i++)
  1967.         PyList_SetItem(names, i, PyString_FromString(m.CategoryName[i]));
  1968.  
  1969.     ids = PyList_New(16);
  1970.     for (i=0;i<16;i++)
  1971.         PyList_SetItem(ids, i, PyInt_FromLong(m.CategoryID[i]));    
  1972.     
  1973.     return Py_BuildValue("{sOsOsisi}", 
  1974.         "category", names,
  1975.         "categoryID", ids,
  1976.         "lastID",    m.lastUniqueID,
  1977.         "sortOrder",    m.sortOrder
  1978.          );
  1979. }
  1980.  
  1981. static PyObject *
  1982. MemoPackAppBlock(self, args)
  1983.     PyObject *self;
  1984.     PyObject *args;
  1985. {
  1986.     char * data;
  1987.     int length;
  1988.     PyObject *names, *ids;
  1989.     struct MemoAppInfo m;
  1990.     int i;
  1991.     PyObject *result, *o, *e, *c;
  1992.     
  1993.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &o))
  1994.         return NULL;
  1995.     
  1996.     data = malloc(0xFFFF);
  1997.     
  1998.     i = 0;
  1999.     if (e=PyDict_GetItemString(o, "category")) {
  2000.         for(i=0;i<16;i++) {
  2001.             c = PyList_GetItem(e, i);
  2002.             if (c)
  2003.                 strcpy(m.CategoryName[i], PyString_AsString(c));
  2004.             else
  2005.                 break;
  2006.         }
  2007.     }
  2008.     for(;i<16;i++)
  2009.         m.CategoryName[i][0] = '\0';
  2010.  
  2011.     i = 0;
  2012.     if (e=PyDict_GetItemString(o, "categoryID")) {
  2013.         for(i=0;i<16;i++) {
  2014.             c = PyList_GetItem(e, i);
  2015.             if (c)
  2016.                 m.CategoryID[i] = PyInt_AsLong(c);
  2017.             else
  2018.                 break;
  2019.         }
  2020.     }
  2021.     for(;i<16;i++)
  2022.         m.CategoryID[i] = 0;
  2023.  
  2024.     m.sortOrder = (e=PyDict_GetItemString(o, "sortOrder")) ? PyInt_AsLong(e) : 0;
  2025.     m.lastUniqueID = (e=PyDict_GetItemString(o, "lastID")) ? PyInt_AsLong(e) : 0;
  2026.     
  2027.     pack_MemoAppInfo(&m, data, &length);
  2028.     
  2029.     result = Py_BuildValue("s#", data, length);
  2030.     
  2031.     free(data);
  2032.     return result;
  2033. }
  2034.  
  2035. static PyObject *
  2036. TodoUnpack(self, args)
  2037.     PyObject *self;
  2038.     PyObject *args;
  2039. {
  2040.     char * data;
  2041.     int length;
  2042.     struct ToDo m;
  2043.     PyObject * result;
  2044.     
  2045.     if (!PyArg_ParseTuple(args, "s#", &data, &length))
  2046.         return NULL;
  2047.     
  2048.     unpack_ToDo(&m, data, length);
  2049.     
  2050.     result = Py_BuildValue("{sOsisiszsz}", 
  2051.         "due", m.indefinite ? Py_BuildValue("") : BuildTm(&m.due),
  2052.         "priority",m.priority,
  2053.         "complete",m.complete,
  2054.         "description", m.description,
  2055.         "note", m.note
  2056.         );
  2057.     
  2058.     free_ToDo(&m);
  2059.     
  2060.     return result;
  2061. }
  2062.  
  2063. static PyObject *
  2064. TodoPack(self, args)
  2065.     PyObject *self;
  2066.     PyObject *args;
  2067. {
  2068.     char * data;
  2069.     int length;
  2070.     struct ToDo m;
  2071.     PyObject * o, *e;
  2072.     
  2073.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &o))
  2074.         return NULL;
  2075.     
  2076.     data = malloc(0xffff);
  2077.  
  2078.     m.description = (e=PyDict_GetItemString(o, "description")) ? PyString_AsString(e) : 0;
  2079.     m.note = (e=PyDict_GetItemString(o, "note")) ? PyString_AsString(e) : 0;
  2080.     m.complete = (e=PyDict_GetItemString(o, "complete")) ? PyInt_AsLong(e) : 0;
  2081.     m.priority = (e=PyDict_GetItemString(o, "priority")) ? PyInt_AsLong(e) : 0;
  2082.     m.indefinite = 1;
  2083.     memset(&m.due, '\0', sizeof(struct tm));
  2084.     if (e=PyDict_GetItemString(o, "due"))
  2085.         if (PyTuple_Check(e)) {
  2086.             ParseTm(e, &m.due);
  2087.             m.indefinite=0;
  2088.         }
  2089.     
  2090.     pack_ToDo(&m, data, &length);
  2091.     
  2092.     o = Py_BuildValue("s#", data, length);
  2093.     free(data);
  2094.     
  2095.     return o;
  2096. }
  2097.  
  2098. static PyObject *
  2099. TodoUnpackAppBlock(self, args)
  2100.     PyObject *self;
  2101.     PyObject *args;
  2102. {
  2103.     char * data;
  2104.     int length;
  2105.     PyObject *names, *ids;
  2106.     struct ToDoAppInfo m;
  2107.     int i;
  2108.     
  2109.     if (!PyArg_ParseTuple(args, "s#", &data, &length))
  2110.         return NULL;
  2111.     
  2112.     unpack_ToDoAppInfo(&m, data, length);
  2113.     
  2114.     names = PyList_New(16);
  2115.     for (i=0;i<16;i++)
  2116.         PyList_SetItem(names, i, PyString_FromString(m.CategoryName[i]));
  2117.  
  2118.     ids = PyList_New(16);
  2119.     for (i=0;i<16;i++)
  2120.         PyList_SetItem(ids, i, PyInt_FromLong(m.CategoryID[i]));    
  2121.     
  2122.     return Py_BuildValue("{sOsOsisisi}", 
  2123.         "category", names,
  2124.         "categoryID", ids,
  2125.         "lastID",    m.lastUniqueID,
  2126.         "sortByPriority",    m.sortByPriority,
  2127.         "dirty",    m.dirty
  2128.          );
  2129. }
  2130.  
  2131. static PyObject *
  2132. TodoPackAppBlock(self, args)
  2133.     PyObject *self;
  2134.     PyObject *args;
  2135. {
  2136.     char * data;
  2137.     int length;
  2138.     PyObject *names, *ids;
  2139.     struct ToDoAppInfo m;
  2140.     int i;
  2141.     PyObject *result, *o, *e, *c;
  2142.     
  2143.     if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &o))
  2144.         return NULL;
  2145.     
  2146.     data = malloc(0xFFFF);
  2147.     
  2148.     i = 0;
  2149.     if (e=PyDict_GetItemString(o, "category")) {
  2150.         for(i=0;i<16;i++) {
  2151.             c = PyList_GetItem(e, i);
  2152.             if (c)
  2153.                 strcpy(m.CategoryName[i], PyString_AsString(c));
  2154.             else
  2155.                 break;
  2156.         }
  2157.     }
  2158.     for(;i<16;i++)
  2159.         m.CategoryName[i][0] = '\0';
  2160.  
  2161.     i = 0;
  2162.     if (e=PyDict_GetItemString(o, "categoryID")) {
  2163.         for(i=0;i<16;i++) {
  2164.             c = PyList_GetItem(e, i);
  2165.             if (c)
  2166.                 m.CategoryID[i] = PyInt_AsLong(c);
  2167.             else
  2168.                 break;
  2169.         }
  2170.     }
  2171.     for(;i<16;i++)
  2172.         m.CategoryID[i] = 0;
  2173.  
  2174.     m.sortByPriority = (e=PyDict_GetItemString(o, "sortByPriority")) ? PyInt_AsLong(e) : 0;
  2175.     m.dirty = (e=PyDict_GetItemString(o, "dirty")) ? PyInt_AsLong(e) : 0;
  2176.     m.lastUniqueID = (e=PyDict_GetItemString(o, "lastID")) ? PyInt_AsLong(e) : 0;
  2177.     
  2178.     pack_ToDoAppInfo(&m, data, &length);
  2179.     
  2180.     result = Py_BuildValue("s#", data, length);
  2181.     
  2182.     free(data);
  2183.     return result;
  2184. }
  2185.  
  2186. static PyObject *
  2187. RPCPack(self, args)
  2188.     PyObject *self;
  2189.     PyObject *args;
  2190. {
  2191.     long trap;
  2192.     char * reply;
  2193.     int r;
  2194.     PyTupleObject *rpcargs, *rpctypes;
  2195.     RpcObject * result;
  2196.     int i;
  2197.     
  2198.     if (!PyArg_ParseTuple(args, "lzO!O!", &trap, &reply, &PyTuple_Type, &rpctypes, &PyTuple_Type, &rpcargs))
  2199.         return NULL;
  2200.  
  2201.  
  2202.     if (PyTuple_Size(rpcargs) != PyTuple_Size(rpctypes)) {
  2203.         PyErr_SetString(Error, "types and arguments must match");
  2204.         return NULL;
  2205.     }
  2206.  
  2207.     for(i=0;i<PyList_Size(rpcargs);i++) {
  2208.         PyObject * type = PyTuple_GetItem(rpctypes, i);
  2209.         PyObject * value = PyTuple_GetItem(rpcargs, i);
  2210.         if (!PyString_Check(type)) {
  2211.             PyErr_SetString(Error, "type must be string");
  2212.             return NULL;
  2213.         } else if (!PyInt_Check(value) && !PyString_Check(value)) {
  2214.             PyErr_SetString(Error, "argument must be string or integer");
  2215.             return NULL;
  2216.         }
  2217.     }
  2218.     
  2219.     result = PyObject_NEW(RpcObject, &Rpc_Type);
  2220.     result->p = malloc(sizeof(struct RPC_params));
  2221.     /*result->rpcargs = rpcargs;
  2222.     Py_INCREF(rpcargs);*/
  2223.  
  2224.     result->p->trap = trap;
  2225.     
  2226.     if ((reply == 0) || (strlen(reply)==0))
  2227.         r = RPC_NoReply;
  2228.     else
  2229.         switch (reply[0]) {
  2230.             case 'i': case 'l': case 's': case 'b': case 'c':
  2231.                 r = RPC_IntReply;
  2232.                 break;
  2233.             case 'p': case 'h': case '*': case '&':
  2234.                 r = RPC_PtrReply;
  2235.                 break;
  2236.             default:
  2237.                 r = RPC_NoReply;
  2238.         }
  2239.         
  2240.     result->p->reply = r;
  2241.     for(i=0;i<PyTuple_Size(rpcargs);i++) {
  2242.         char * type = PyString_AsString(PyTuple_GetItem(rpctypes, i));
  2243.         PyObject * value = PyTuple_GetItem(rpcargs, i);
  2244.         char * data = 0;
  2245.         int len = 0;
  2246.         unsigned long arg;
  2247.         int ref=0;
  2248.         if (type[0] == '&') {
  2249.             result->p->param[i].byRef = 1;    
  2250.             type++;
  2251.         } else 
  2252.             result->p->param[i].byRef = 0;    
  2253.         result->p->param[i].invert = 0;
  2254.         result->p->param[i].data = &result->p->param[i].arg;
  2255.  
  2256.         switch(type[0]) {
  2257.         case '*': case 'p':
  2258.             result->p->param[i].data = malloc(PyString_Size(value)+1);
  2259.             memcpy(result->p->param[i].data, PyString_AsString(value), PyString_Size(value)+1);
  2260.             result->p->param[i].size = PyString_Size(value);
  2261.             result->p->param[i].invert = 0;
  2262.             break;
  2263.         case 'b': case 'c':
  2264.             result->p->param[i].arg = PyInt_AsLong(value);
  2265.             result->p->param[i].size = 2;
  2266.             result->p->param[i].invert = 2;
  2267.             break;
  2268.         case 's':
  2269.             result->p->param[i].arg = PyInt_AsLong(value);
  2270.             result->p->param[i].size = 2;
  2271.             result->p->param[i].invert = 1;
  2272.             break;
  2273.         case 'i': case 'l': 
  2274.             result->p->param[i].arg = PyInt_AsLong(value);
  2275.             result->p->param[i].size = 4;
  2276.             result->p->param[i].invert = 1;
  2277.             break;
  2278.         }
  2279.     }
  2280.     result->p->args = i;
  2281.     
  2282.     return (PyObject*)result;
  2283. }
  2284.  
  2285. static PyObject *
  2286. DlpRPC(self, args)
  2287.     DlpObject *self;
  2288.     PyObject *args;
  2289. {
  2290.     long trap;
  2291.     char * reply;
  2292.     int r;
  2293.     RpcObject * rpc;
  2294.     int i;
  2295.     int err;
  2296.     long result;
  2297.     PyObject * out;
  2298.     
  2299.     if (!PyArg_ParseTuple(args, "O!", &Rpc_Type, &rpc))
  2300.         return NULL;
  2301.     
  2302.     err = dlp_RPC(self->socket, rpc->p, &result);
  2303.  
  2304.     out = PyTuple_New(rpc->p->args);
  2305.     
  2306.     for(i=0;i<rpc->p->args;i++) {
  2307.         struct RPC_param * p = &rpc->p->param[i];
  2308.         if (p->invert == 0) {
  2309.             PyTuple_SetItem(out, i, PyString_FromStringAndSize(p->data,p->size));
  2310.         } else {
  2311.             PyTuple_SetItem(out, i, PyInt_FromLong(p->arg));
  2312.         }
  2313.     }
  2314.     
  2315.     return Py_BuildValue("(liO)", result, err, out);
  2316. }
  2317.  
  2318. static PyMethodDef PiFile_methods[] = {
  2319.     {"Records",    FileRecords, 1},
  2320.     {"CheckID",    FileCheckID, 1},
  2321.     {"GetRecord",    FileGetRec, 1},
  2322.     {"GetRecordByID",    FileGetRecById, 1},
  2323.     {"GetResource",    FileGetRsc, 1},
  2324.     {"AddRecord",    FileAddRec, 1},
  2325.     {"AddResource",    FileAddRsc, 1},
  2326.     {"GetAppBlock",    FileGetAppBlock, 1},
  2327.     {"SetAppBlock",    FileGetAppBlock, 1},
  2328.     {"GetSortBlock",FileGetSortBlock, 1},
  2329.     {"SetSortBlock",FileSetSortBlock, 1},
  2330.     {"GetDBInfo",    FileGetDBInfo, 1},
  2331.     {"SetDBInfo",    FileSetDBInfo, 1},
  2332.     {"Install",    FileInstall, 1},
  2333.     {"Retrieve",    FileRetrieve, 1},
  2334.     {"Close",    FileClose, 1},
  2335.     {NULL,    NULL}
  2336. };
  2337.  
  2338. static PyMethodDef Dlp_methods[] = {
  2339.     {"Open",    OpenDB, 1},
  2340.     {"Create",    CreateDB, 1},
  2341.     {"Delete",    DeleteDB, 1},
  2342.     {"Status",    Status, 1},
  2343.     {"Dirty",    Dirty, 1},
  2344.     {"Battery",    Battery, 1},
  2345.     {"Reset",    ResetSystem, 1},
  2346.     {"Close",    Close, 1},
  2347.     {"Abort",    Abort, 1},
  2348.     {"Log",        Log, 1},
  2349.     {"GetTime",    GetTime, 1},
  2350.     {"SetTime",    GetTime, 1},
  2351.     {"CardInfo",    CardInfo, 1},
  2352.     {"SysInfo",    SysInfo, 1},
  2353.     {"GetUserInfo",    GetUserInfo, 1},
  2354.     {"SetUserInfo",    SetUserInfo, 1},
  2355.     {"GetAppPref",    GetAppPref, 1},
  2356.     {"SetAppPref",    SetAppPref, 1},
  2357.     {"GetFeature",    GetFeature, 1},
  2358.     {"GetDBInfo",    GetDBInfo, 1},
  2359.     {"FindDBInfo",    FindDBInfo, 1},
  2360.     {"Call",    CallApp, 1},
  2361.     {"RPC",        DlpRPC, 1},
  2362.     {NULL,    NULL}
  2363. };
  2364.  
  2365. static PyMethodDef DlpDB_methods[] = {
  2366.     {"SetRecord",    SetRec, 1},
  2367.     {"SetResource",    SetRsc, 1},
  2368.     {"GetNextInCategory",    NextCatRec, 1},
  2369.     {"GetNextChanged",    NextModRec, 1},
  2370.     {"GetResource",    GetRsc, 1},
  2371.     {"GetResourceByID",    GetRscById, 1},
  2372.     {"GetRecord",    GetRec, 1},
  2373.     {"GetRecordByID",    GetRecById, 1},
  2374.     {"DeleteRecord",    DeleteRec, 1},
  2375.     {"DeleteRecords",    DeleteAllRec, 1},
  2376.     {"DeleteResource",    DeleteRsc, 1},
  2377.     {"DeleteResources",    DeleteAllRsc, 1},
  2378.     {"Close",    CloseDB, 1},
  2379.     {"Records",    Records, 1},
  2380.     {"RecordIDs",    RecordIDs, 1},
  2381.     {"GetAppBlock",    GetAppBlock, 1},
  2382.     {"SetAppBlock",    SetAppBlock, 1},
  2383.     {"GetSortBlock",GetSortBlock, 1},
  2384.     {"SetSortBlock",SetSortBlock, 1},
  2385.     {"MoveCategory",MoveCategory, 1},
  2386.     {"DeleteCategory",DeleteCategory, 1},
  2387.     {"Purge",    Purge, 1},
  2388.     {"ResetNext",    ResetNext, 1},
  2389.     {"ResetFlags",    ResetFlags, 1},
  2390.     {"Unpack",    DBUnpack, 1},
  2391.     {"Pack",    DBPack, 1},
  2392.     {"UnpackAppBlock",    DBUnpackAppBlock, 1},
  2393.     {"PackAppBlock",    DBPackAppBlock, 1},
  2394.     {NULL,    NULL}
  2395. };
  2396.  
  2397. static PyMethodDef Methods[] = {
  2398.     {"Socket",    Socket, 1},
  2399.     {"Bind",    Bind, 1},
  2400.     {"Read",    Read, 1},
  2401.     {"Write",    Write, 1},
  2402.     {"Accept",    Accept, 1},
  2403.     {"Close",    CloseSocket, 1},
  2404.     {"Listen",    Listen, 1},
  2405.     {"FileOpen",    OpenFile, 1},
  2406.     {"FileCreate",    CreateFile, 1},
  2407.     {"OpenPort",    OpenPort, 1},
  2408.     {"MemoUnpack",    MemoUnpack, 1},
  2409.     {"MemoUnpackAppBlock",    MemoUnpackAppBlock, 1},
  2410.     {"MemoPack",    MemoPack, 1},
  2411.     {"MemoPackAppBlock",    MemoPackAppBlock, 1},
  2412.     {"TodoUnpack",    TodoUnpack, 1},
  2413.     {"TodoUnpackAppBlock",    TodoUnpackAppBlock, 1},
  2414.     {"TodoPack",    TodoPack, 1},
  2415.     {"TodoPackAppBlock",    TodoPackAppBlock, 1},
  2416.     {"PackRPC",    RPCPack, 1},
  2417.     {NULL, NULL}
  2418. };
  2419.  
  2420. #define SetDictInt(string,ch) \
  2421.         PyDict_SetItemString(d,string,PyInt_FromLong((long) (ch)));
  2422.  
  2423. void
  2424. initpdapilot()
  2425. {
  2426.     PyObject *m, *d, *main, *t;
  2427.     main = m = Py_InitModule("pdapilot", Methods);
  2428.     d = PyModule_GetDict(m);
  2429.     Error = PyString_FromString("pdapilot.error");
  2430.     PyDict_SetItemString(d, "error", Error);
  2431.     
  2432.     DBPackers = PyDict_New();
  2433.     PyDict_SetItemString(d, "DBPackers", DBPackers);
  2434.     
  2435.     t = PyTuple_New(4);
  2436.     PyTuple_SetItem(t, 0, PyDict_GetItemString(d, "MemoPack"));
  2437.     PyTuple_SetItem(t, 1, PyDict_GetItemString(d, "MemoUnpack"));
  2438.     PyTuple_SetItem(t, 2, PyDict_GetItemString(d, "MemoPackAppBlock"));
  2439.     PyTuple_SetItem(t, 3, PyDict_GetItemString(d, "MemoUnpackAppBlock"));
  2440.     PyDict_SetItemString(DBPackers, "MemoDB", t);
  2441.     Py_DECREF(t);
  2442.  
  2443.     t = PyTuple_New(4);
  2444.     PyTuple_SetItem(t, 0, PyDict_GetItemString(d, "TodoPack"));
  2445.     PyTuple_SetItem(t, 1, PyDict_GetItemString(d, "TodoUnpack"));
  2446.     PyTuple_SetItem(t, 2, PyDict_GetItemString(d, "TodoPackAppBlock"));
  2447.     PyTuple_SetItem(t, 3, PyDict_GetItemString(d, "TodoUnpackAppBlock"));
  2448.     PyDict_SetItemString(DBPackers, "ToDoDB", t);
  2449.     Py_DECREF(t);
  2450.  
  2451.     SetDictInt("PI_AF_SLP", PI_AF_SLP);
  2452.  
  2453.     SetDictInt("PI_PF_SLP", PI_PF_SLP);
  2454.     SetDictInt("PI_PF_PADP", PI_PF_PADP);
  2455.     SetDictInt("PI_PF_LOOP", PI_PF_LOOP);
  2456.  
  2457.     SetDictInt("PI_SOCK_STREAM", PI_SOCK_STREAM);
  2458.     SetDictInt("PI_SOCK_DGRAM", PI_SOCK_DGRAM);
  2459.     SetDictInt("PI_SOCK_RAW", PI_SOCK_RAW);
  2460.     SetDictInt("PI_SOCK_SEQPACKET", PI_SOCK_SEQPACKET);
  2461.  
  2462.     SetDictInt("PI_PilotSocketDLP", PI_PilotSocketDLP);
  2463.     SetDictInt("PI_PilotSocketConsole", PI_PilotSocketConsole);
  2464.     SetDictInt("PI_PilotSocketDebugger", PI_PilotSocketDebugger);
  2465.     SetDictInt("PI_PilotSockerRemoteUI", PI_PilotSocketRemoteUI);    
  2466.  
  2467.     SetDictInt("DBResource", dlpDBFlagResource);
  2468.     SetDictInt("DBReadOnly", dlpDBFlagReadOnly);
  2469.     SetDictInt("DBAppBlockDirty", dlpDBFlagAppInfoDirty);
  2470.     SetDictInt("DBBackup", dlpDBFlagBackup);
  2471.     SetDictInt("DBOpen", dlpDBFlagOpen);
  2472.     SetDictInt("DBNew", dlpDBFlagNewer);
  2473.     SetDictInt("DBReset", dlpDBFlagReset);
  2474.     
  2475.     SetDictInt("OpenDBRead", dlpOpenRead);
  2476.     SetDictInt("OpenDBWrite", dlpOpenWrite);
  2477.     SetDictInt("OpenDBReadWrite", dlpOpenReadWrite);
  2478.     SetDictInt("OpenDBExclusive", dlpOpenExclusive);
  2479.     SetDictInt("OpenDBSecret", dlpOpenSecret);
  2480.  
  2481.     SetDictInt("EndNormal", dlpEndCodeNormal);
  2482.     SetDictInt("EndMemory", dlpEndCodeOutOfMemory);
  2483.     SetDictInt("EndCancelled", dlpEndCodeUserCan);
  2484.     SetDictInt("EndOther", dlpEndCodeOther);
  2485.     
  2486.     SetDictInt("RecDeleted", dlpRecAttrDeleted);
  2487.     SetDictInt("RecDirty", dlpRecAttrDirty);
  2488.     SetDictInt("RecBusy", dlpRecAttrBusy);
  2489.     SetDictInt("RecSecret", dlpRecAttrSecret);
  2490.     SetDictInt("RecArchived", dlpRecAttrArchived);
  2491.  
  2492. }
  2493.