This file is indexed.

/usr/lib/python2.7/dist-packages/pisock.py is in python-pisock 0.12.5-dfsg-2+b3.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
# This file was created automatically by SWIG 1.3.27.
# Don't modify this file, modify the SWIG interface instead.

import _pisock

# This file is compatible with both classic and new-style classes.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "this"):
        if isinstance(value, class_type):
            self.__dict__[name] = value.this
            if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
            del value.thisown
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static) or hasattr(self,name) or (name == "thisown"):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError,name

import types
try:
    _object = types.ObjectType
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0
del types


from pisockextras import *

error = _pisock.error 

PI_ERR_PROT_ABORTED = _pisock.PI_ERR_PROT_ABORTED
PI_ERR_PROT_INCOMPATIBLE = _pisock.PI_ERR_PROT_INCOMPATIBLE
PI_ERR_PROT_BADPACKET = _pisock.PI_ERR_PROT_BADPACKET
PI_ERR_SOCK_DISCONNECTED = _pisock.PI_ERR_SOCK_DISCONNECTED
PI_ERR_SOCK_INVALID = _pisock.PI_ERR_SOCK_INVALID
PI_ERR_SOCK_TIMEOUT = _pisock.PI_ERR_SOCK_TIMEOUT
PI_ERR_SOCK_CANCELED = _pisock.PI_ERR_SOCK_CANCELED
PI_ERR_SOCK_IO = _pisock.PI_ERR_SOCK_IO
PI_ERR_SOCK_LISTENER = _pisock.PI_ERR_SOCK_LISTENER
PI_ERR_DLP_BUFSIZE = _pisock.PI_ERR_DLP_BUFSIZE
PI_ERR_DLP_PALMOS = _pisock.PI_ERR_DLP_PALMOS
PI_ERR_DLP_UNSUPPORTED = _pisock.PI_ERR_DLP_UNSUPPORTED
PI_ERR_DLP_SOCKET = _pisock.PI_ERR_DLP_SOCKET
PI_ERR_DLP_DATASIZE = _pisock.PI_ERR_DLP_DATASIZE
PI_ERR_DLP_COMMAND = _pisock.PI_ERR_DLP_COMMAND
PI_ERR_FILE_INVALID = _pisock.PI_ERR_FILE_INVALID
PI_ERR_FILE_ERROR = _pisock.PI_ERR_FILE_ERROR
PI_ERR_FILE_ABORTED = _pisock.PI_ERR_FILE_ABORTED
PI_ERR_FILE_NOT_FOUND = _pisock.PI_ERR_FILE_NOT_FOUND
PI_ERR_FILE_ALREADY_EXISTS = _pisock.PI_ERR_FILE_ALREADY_EXISTS
PI_ERR_GENERIC_MEMORY = _pisock.PI_ERR_GENERIC_MEMORY
PI_ERR_GENERIC_ARGUMENT = _pisock.PI_ERR_GENERIC_ARGUMENT
PI_ERR_GENERIC_SYSTEM = _pisock.PI_ERR_GENERIC_SYSTEM
PI_AF_PILOT = _pisock.PI_AF_PILOT
PI_SOCK_STREAM = _pisock.PI_SOCK_STREAM
PI_SOCK_RAW = _pisock.PI_SOCK_RAW
PI_CMD_CMP = _pisock.PI_CMD_CMP
PI_CMD_NET = _pisock.PI_CMD_NET
PI_CMD_SYS = _pisock.PI_CMD_SYS
PI_MSG_PEEK = _pisock.PI_MSG_PEEK
PI_PF_DEV = _pisock.PI_PF_DEV
PI_PF_SLP = _pisock.PI_PF_SLP
PI_PF_SYS = _pisock.PI_PF_SYS
PI_PF_PADP = _pisock.PI_PF_PADP
PI_PF_NET = _pisock.PI_PF_NET
PI_PF_DLP = _pisock.PI_PF_DLP
PI_LEVEL_DEV = _pisock.PI_LEVEL_DEV
PI_LEVEL_SLP = _pisock.PI_LEVEL_SLP
PI_LEVEL_PADP = _pisock.PI_LEVEL_PADP
PI_LEVEL_NET = _pisock.PI_LEVEL_NET
PI_LEVEL_SYS = _pisock.PI_LEVEL_SYS
PI_LEVEL_CMP = _pisock.PI_LEVEL_CMP
PI_LEVEL_DLP = _pisock.PI_LEVEL_DLP
PI_LEVEL_SOCK = _pisock.PI_LEVEL_SOCK
PI_DEV_RATE = _pisock.PI_DEV_RATE
PI_DEV_ESTRATE = _pisock.PI_DEV_ESTRATE
PI_DEV_HIGHRATE = _pisock.PI_DEV_HIGHRATE
PI_DEV_TIMEOUT = _pisock.PI_DEV_TIMEOUT
PI_SLP_DEST = _pisock.PI_SLP_DEST
PI_SLP_LASTDEST = _pisock.PI_SLP_LASTDEST
PI_SLP_SRC = _pisock.PI_SLP_SRC
PI_SLP_LASTSRC = _pisock.PI_SLP_LASTSRC
PI_SLP_TYPE = _pisock.PI_SLP_TYPE
PI_SLP_LASTTYPE = _pisock.PI_SLP_LASTTYPE
PI_SLP_TXID = _pisock.PI_SLP_TXID
PI_SLP_LASTTXID = _pisock.PI_SLP_LASTTXID
PI_PADP_TYPE = _pisock.PI_PADP_TYPE
PI_PADP_LASTTYPE = _pisock.PI_PADP_LASTTYPE
PI_PADP_FREEZE_TXID = _pisock.PI_PADP_FREEZE_TXID
PI_PADP_USE_LONG_FORMAT = _pisock.PI_PADP_USE_LONG_FORMAT
PI_CMP_TYPE = _pisock.PI_CMP_TYPE
PI_CMP_FLAGS = _pisock.PI_CMP_FLAGS
PI_CMP_VERS = _pisock.PI_CMP_VERS
PI_CMP_BAUD = _pisock.PI_CMP_BAUD
PI_NET_TYPE = _pisock.PI_NET_TYPE
PI_NET_SPLIT_WRITES = _pisock.PI_NET_SPLIT_WRITES
PI_NET_WRITE_CHUNKSIZE = _pisock.PI_NET_WRITE_CHUNKSIZE
PI_SOCK_STATE = _pisock.PI_SOCK_STATE
PI_SOCK_HONOR_RX_TIMEOUT = _pisock.PI_SOCK_HONOR_RX_TIMEOUT
class pi_socket_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pi_socket_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pi_socket_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C pi_socket_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["sd"] = _pisock.pi_socket_t_sd_set
    __swig_getmethods__["sd"] = _pisock.pi_socket_t_sd_get
    if _newclass:sd = property(_pisock.pi_socket_t_sd_get, _pisock.pi_socket_t_sd_set)
    __swig_setmethods__["type"] = _pisock.pi_socket_t_type_set
    __swig_getmethods__["type"] = _pisock.pi_socket_t_type_get
    if _newclass:type = property(_pisock.pi_socket_t_type_get, _pisock.pi_socket_t_type_set)
    __swig_setmethods__["protocol"] = _pisock.pi_socket_t_protocol_set
    __swig_getmethods__["protocol"] = _pisock.pi_socket_t_protocol_get
    if _newclass:protocol = property(_pisock.pi_socket_t_protocol_get, _pisock.pi_socket_t_protocol_set)
    __swig_setmethods__["cmd"] = _pisock.pi_socket_t_cmd_set
    __swig_getmethods__["cmd"] = _pisock.pi_socket_t_cmd_get
    if _newclass:cmd = property(_pisock.pi_socket_t_cmd_get, _pisock.pi_socket_t_cmd_set)
    __swig_setmethods__["laddr"] = _pisock.pi_socket_t_laddr_set
    __swig_getmethods__["laddr"] = _pisock.pi_socket_t_laddr_get
    if _newclass:laddr = property(_pisock.pi_socket_t_laddr_get, _pisock.pi_socket_t_laddr_set)
    __swig_setmethods__["laddrlen"] = _pisock.pi_socket_t_laddrlen_set
    __swig_getmethods__["laddrlen"] = _pisock.pi_socket_t_laddrlen_get
    if _newclass:laddrlen = property(_pisock.pi_socket_t_laddrlen_get, _pisock.pi_socket_t_laddrlen_set)
    __swig_setmethods__["raddr"] = _pisock.pi_socket_t_raddr_set
    __swig_getmethods__["raddr"] = _pisock.pi_socket_t_raddr_get
    if _newclass:raddr = property(_pisock.pi_socket_t_raddr_get, _pisock.pi_socket_t_raddr_set)
    __swig_setmethods__["raddrlen"] = _pisock.pi_socket_t_raddrlen_set
    __swig_getmethods__["raddrlen"] = _pisock.pi_socket_t_raddrlen_get
    if _newclass:raddrlen = property(_pisock.pi_socket_t_raddrlen_get, _pisock.pi_socket_t_raddrlen_set)
    __swig_setmethods__["protocol_queue"] = _pisock.pi_socket_t_protocol_queue_set
    __swig_getmethods__["protocol_queue"] = _pisock.pi_socket_t_protocol_queue_get
    if _newclass:protocol_queue = property(_pisock.pi_socket_t_protocol_queue_get, _pisock.pi_socket_t_protocol_queue_set)
    __swig_setmethods__["queue_len"] = _pisock.pi_socket_t_queue_len_set
    __swig_getmethods__["queue_len"] = _pisock.pi_socket_t_queue_len_get
    if _newclass:queue_len = property(_pisock.pi_socket_t_queue_len_get, _pisock.pi_socket_t_queue_len_set)
    __swig_setmethods__["cmd_queue"] = _pisock.pi_socket_t_cmd_queue_set
    __swig_getmethods__["cmd_queue"] = _pisock.pi_socket_t_cmd_queue_get
    if _newclass:cmd_queue = property(_pisock.pi_socket_t_cmd_queue_get, _pisock.pi_socket_t_cmd_queue_set)
    __swig_setmethods__["cmd_len"] = _pisock.pi_socket_t_cmd_len_set
    __swig_getmethods__["cmd_len"] = _pisock.pi_socket_t_cmd_len_get
    if _newclass:cmd_len = property(_pisock.pi_socket_t_cmd_len_get, _pisock.pi_socket_t_cmd_len_set)
    __swig_setmethods__["device"] = _pisock.pi_socket_t_device_set
    __swig_getmethods__["device"] = _pisock.pi_socket_t_device_get
    if _newclass:device = property(_pisock.pi_socket_t_device_get, _pisock.pi_socket_t_device_set)
    __swig_setmethods__["state"] = _pisock.pi_socket_t_state_set
    __swig_getmethods__["state"] = _pisock.pi_socket_t_state_get
    if _newclass:state = property(_pisock.pi_socket_t_state_get, _pisock.pi_socket_t_state_set)
    __swig_setmethods__["honor_rx_to"] = _pisock.pi_socket_t_honor_rx_to_set
    __swig_getmethods__["honor_rx_to"] = _pisock.pi_socket_t_honor_rx_to_get
    if _newclass:honor_rx_to = property(_pisock.pi_socket_t_honor_rx_to_get, _pisock.pi_socket_t_honor_rx_to_set)
    __swig_setmethods__["command"] = _pisock.pi_socket_t_command_set
    __swig_getmethods__["command"] = _pisock.pi_socket_t_command_get
    if _newclass:command = property(_pisock.pi_socket_t_command_get, _pisock.pi_socket_t_command_set)
    __swig_setmethods__["accept_to"] = _pisock.pi_socket_t_accept_to_set
    __swig_getmethods__["accept_to"] = _pisock.pi_socket_t_accept_to_get
    if _newclass:accept_to = property(_pisock.pi_socket_t_accept_to_get, _pisock.pi_socket_t_accept_to_set)
    __swig_setmethods__["dlprecord"] = _pisock.pi_socket_t_dlprecord_set
    __swig_getmethods__["dlprecord"] = _pisock.pi_socket_t_dlprecord_get
    if _newclass:dlprecord = property(_pisock.pi_socket_t_dlprecord_get, _pisock.pi_socket_t_dlprecord_set)
    __swig_setmethods__["dlpversion"] = _pisock.pi_socket_t_dlpversion_set
    __swig_getmethods__["dlpversion"] = _pisock.pi_socket_t_dlpversion_get
    if _newclass:dlpversion = property(_pisock.pi_socket_t_dlpversion_get, _pisock.pi_socket_t_dlpversion_set)
    __swig_setmethods__["maxrecsize"] = _pisock.pi_socket_t_maxrecsize_set
    __swig_getmethods__["maxrecsize"] = _pisock.pi_socket_t_maxrecsize_get
    if _newclass:maxrecsize = property(_pisock.pi_socket_t_maxrecsize_get, _pisock.pi_socket_t_maxrecsize_set)
    __swig_setmethods__["last_error"] = _pisock.pi_socket_t_last_error_set
    __swig_getmethods__["last_error"] = _pisock.pi_socket_t_last_error_get
    if _newclass:last_error = property(_pisock.pi_socket_t_last_error_get, _pisock.pi_socket_t_last_error_set)
    __swig_setmethods__["palmos_error"] = _pisock.pi_socket_t_palmos_error_set
    __swig_getmethods__["palmos_error"] = _pisock.pi_socket_t_palmos_error_get
    if _newclass:palmos_error = property(_pisock.pi_socket_t_palmos_error_get, _pisock.pi_socket_t_palmos_error_set)
    def __init__(self, *args):
        _swig_setattr(self, pi_socket_t, 'this', _pisock.new_pi_socket_t(*args))
        _swig_setattr(self, pi_socket_t, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_pi_socket_t):
        try:
            if self.thisown: destroy(self)
        except: pass


class pi_socket_tPtr(pi_socket_t):
    def __init__(self, this):
        _swig_setattr(self, pi_socket_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, pi_socket_t, 'thisown', 0)
        self.__class__ = pi_socket_t
_pisock.pi_socket_t_swigregister(pi_socket_tPtr)
dlp_ReadRecordIDList = _pisock.dlp_ReadRecordIDList

pi_file_install = _pisock.pi_file_install

pi_file_retrieve = _pisock.pi_file_retrieve


class pi_socket_list_t(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, pi_socket_list_t, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, pi_socket_list_t, name)
    def __repr__(self):
        return "<%s.%s; proxy of C pi_socket_list_t instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["ps"] = _pisock.pi_socket_list_t_ps_set
    __swig_getmethods__["ps"] = _pisock.pi_socket_list_t_ps_get
    if _newclass:ps = property(_pisock.pi_socket_list_t_ps_get, _pisock.pi_socket_list_t_ps_set)
    __swig_setmethods__["next"] = _pisock.pi_socket_list_t_next_set
    __swig_getmethods__["next"] = _pisock.pi_socket_list_t_next_get
    if _newclass:next = property(_pisock.pi_socket_list_t_next_get, _pisock.pi_socket_list_t_next_set)
    def __init__(self, *args):
        _swig_setattr(self, pi_socket_list_t, 'this', _pisock.new_pi_socket_list_t(*args))
        _swig_setattr(self, pi_socket_list_t, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_pi_socket_list_t):
        try:
            if self.thisown: destroy(self)
        except: pass


class pi_socket_list_tPtr(pi_socket_list_t):
    def __init__(self, this):
        _swig_setattr(self, pi_socket_list_t, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, pi_socket_list_t, 'thisown', 0)
        self.__class__ = pi_socket_list_t
_pisock.pi_socket_list_t_swigregister(pi_socket_list_tPtr)


pi_socket = _pisock.pi_socket

pi_socket_setsd = _pisock.pi_socket_setsd

pi_getsockname = _pisock.pi_getsockname

pi_getsockpeer = _pisock.pi_getsockpeer

pi_getsockopt = _pisock.pi_getsockopt

pi_setsockopt = _pisock.pi_setsockopt

pi_protocol = _pisock.pi_protocol

pi_protocol_next = _pisock.pi_protocol_next

pi_socket_connected = _pisock.pi_socket_connected

pi_connect = _pisock.pi_connect

pi_bind = _pisock.pi_bind

pi_listen = _pisock.pi_listen

pi_accept = _pisock.pi_accept

pi_accept_to = _pisock.pi_accept_to

pi_close = _pisock.pi_close

pi_send = _pisock.pi_send

pi_recv = _pisock.pi_recv

pi_read = _pisock.pi_read

pi_write = _pisock.pi_write

pi_flush = _pisock.pi_flush

pi_error = _pisock.pi_error

pi_set_error = _pisock.pi_set_error

pi_palmos_error = _pisock.pi_palmos_error

pi_set_palmos_error = _pisock.pi_set_palmos_error

pi_reset_errors = _pisock.pi_reset_errors

pi_version = _pisock.pi_version

pi_maxrecsize = _pisock.pi_maxrecsize

pi_tickle = _pisock.pi_tickle

pi_watchdog = _pisock.pi_watchdog
PI_DLP_VERSION_MAJOR = _pisock.PI_DLP_VERSION_MAJOR
PI_DLP_VERSION_MINOR = _pisock.PI_DLP_VERSION_MINOR
vfsMountFlagsUseThisFileSystem = _pisock.vfsMountFlagsUseThisFileSystem
vfsMAXFILENAME = _pisock.vfsMAXFILENAME
vfsInvalidVolRef = _pisock.vfsInvalidVolRef
vfsInvalidFileRef = _pisock.vfsInvalidFileRef
class VFSDirInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VFSDirInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VFSDirInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C VFSDirInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["attr"] = _pisock.VFSDirInfo_attr_set
    __swig_getmethods__["attr"] = _pisock.VFSDirInfo_attr_get
    if _newclass:attr = property(_pisock.VFSDirInfo_attr_get, _pisock.VFSDirInfo_attr_set)
    __swig_setmethods__["name"] = _pisock.VFSDirInfo_name_set
    __swig_getmethods__["name"] = _pisock.VFSDirInfo_name_get
    if _newclass:name = property(_pisock.VFSDirInfo_name_get, _pisock.VFSDirInfo_name_set)
    def __init__(self, *args):
        _swig_setattr(self, VFSDirInfo, 'this', _pisock.new_VFSDirInfo(*args))
        _swig_setattr(self, VFSDirInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_VFSDirInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class VFSDirInfoPtr(VFSDirInfo):
    def __init__(self, this):
        _swig_setattr(self, VFSDirInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, VFSDirInfo, 'thisown', 0)
        self.__class__ = VFSDirInfo
_pisock.VFSDirInfo_swigregister(VFSDirInfoPtr)

class VFSAnyMountParam(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VFSAnyMountParam, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VFSAnyMountParam, name)
    def __repr__(self):
        return "<%s.%s; proxy of C VFSAnyMountParam instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["volRefNum"] = _pisock.VFSAnyMountParam_volRefNum_set
    __swig_getmethods__["volRefNum"] = _pisock.VFSAnyMountParam_volRefNum_get
    if _newclass:volRefNum = property(_pisock.VFSAnyMountParam_volRefNum_get, _pisock.VFSAnyMountParam_volRefNum_set)
    __swig_setmethods__["reserved"] = _pisock.VFSAnyMountParam_reserved_set
    __swig_getmethods__["reserved"] = _pisock.VFSAnyMountParam_reserved_get
    if _newclass:reserved = property(_pisock.VFSAnyMountParam_reserved_get, _pisock.VFSAnyMountParam_reserved_set)
    __swig_setmethods__["mountClass"] = _pisock.VFSAnyMountParam_mountClass_set
    __swig_getmethods__["mountClass"] = _pisock.VFSAnyMountParam_mountClass_get
    if _newclass:mountClass = property(_pisock.VFSAnyMountParam_mountClass_get, _pisock.VFSAnyMountParam_mountClass_set)
    def __init__(self, *args):
        _swig_setattr(self, VFSAnyMountParam, 'this', _pisock.new_VFSAnyMountParam(*args))
        _swig_setattr(self, VFSAnyMountParam, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_VFSAnyMountParam):
        try:
            if self.thisown: destroy(self)
        except: pass


class VFSAnyMountParamPtr(VFSAnyMountParam):
    def __init__(self, this):
        _swig_setattr(self, VFSAnyMountParam, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, VFSAnyMountParam, 'thisown', 0)
        self.__class__ = VFSAnyMountParam
_pisock.VFSAnyMountParam_swigregister(VFSAnyMountParamPtr)

class VFSSlotMountParam(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VFSSlotMountParam, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VFSSlotMountParam, name)
    def __repr__(self):
        return "<%s.%s; proxy of C VFSSlotMountParam instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["vfsMountParam"] = _pisock.VFSSlotMountParam_vfsMountParam_set
    __swig_getmethods__["vfsMountParam"] = _pisock.VFSSlotMountParam_vfsMountParam_get
    if _newclass:vfsMountParam = property(_pisock.VFSSlotMountParam_vfsMountParam_get, _pisock.VFSSlotMountParam_vfsMountParam_set)
    __swig_setmethods__["slotLibRefNum"] = _pisock.VFSSlotMountParam_slotLibRefNum_set
    __swig_getmethods__["slotLibRefNum"] = _pisock.VFSSlotMountParam_slotLibRefNum_get
    if _newclass:slotLibRefNum = property(_pisock.VFSSlotMountParam_slotLibRefNum_get, _pisock.VFSSlotMountParam_slotLibRefNum_set)
    __swig_setmethods__["slotRefNum"] = _pisock.VFSSlotMountParam_slotRefNum_set
    __swig_getmethods__["slotRefNum"] = _pisock.VFSSlotMountParam_slotRefNum_get
    if _newclass:slotRefNum = property(_pisock.VFSSlotMountParam_slotRefNum_get, _pisock.VFSSlotMountParam_slotRefNum_set)
    def __init__(self, *args):
        _swig_setattr(self, VFSSlotMountParam, 'this', _pisock.new_VFSSlotMountParam(*args))
        _swig_setattr(self, VFSSlotMountParam, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_VFSSlotMountParam):
        try:
            if self.thisown: destroy(self)
        except: pass


class VFSSlotMountParamPtr(VFSSlotMountParam):
    def __init__(self, this):
        _swig_setattr(self, VFSSlotMountParam, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, VFSSlotMountParam, 'thisown', 0)
        self.__class__ = VFSSlotMountParam
_pisock.VFSSlotMountParam_swigregister(VFSSlotMountParamPtr)

class VFSInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, VFSInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, VFSInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C VFSInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["attributes"] = _pisock.VFSInfo_attributes_set
    __swig_getmethods__["attributes"] = _pisock.VFSInfo_attributes_get
    if _newclass:attributes = property(_pisock.VFSInfo_attributes_get, _pisock.VFSInfo_attributes_set)
    __swig_setmethods__["fsType"] = _pisock.VFSInfo_fsType_set
    __swig_getmethods__["fsType"] = _pisock.VFSInfo_fsType_get
    if _newclass:fsType = property(_pisock.VFSInfo_fsType_get, _pisock.VFSInfo_fsType_set)
    __swig_setmethods__["fsCreator"] = _pisock.VFSInfo_fsCreator_set
    __swig_getmethods__["fsCreator"] = _pisock.VFSInfo_fsCreator_get
    if _newclass:fsCreator = property(_pisock.VFSInfo_fsCreator_get, _pisock.VFSInfo_fsCreator_set)
    __swig_setmethods__["mountClass"] = _pisock.VFSInfo_mountClass_set
    __swig_getmethods__["mountClass"] = _pisock.VFSInfo_mountClass_get
    if _newclass:mountClass = property(_pisock.VFSInfo_mountClass_get, _pisock.VFSInfo_mountClass_set)
    __swig_setmethods__["slotLibRefNum"] = _pisock.VFSInfo_slotLibRefNum_set
    __swig_getmethods__["slotLibRefNum"] = _pisock.VFSInfo_slotLibRefNum_get
    if _newclass:slotLibRefNum = property(_pisock.VFSInfo_slotLibRefNum_get, _pisock.VFSInfo_slotLibRefNum_set)
    __swig_setmethods__["slotRefNum"] = _pisock.VFSInfo_slotRefNum_set
    __swig_getmethods__["slotRefNum"] = _pisock.VFSInfo_slotRefNum_get
    if _newclass:slotRefNum = property(_pisock.VFSInfo_slotRefNum_get, _pisock.VFSInfo_slotRefNum_set)
    __swig_setmethods__["mediaType"] = _pisock.VFSInfo_mediaType_set
    __swig_getmethods__["mediaType"] = _pisock.VFSInfo_mediaType_get
    if _newclass:mediaType = property(_pisock.VFSInfo_mediaType_get, _pisock.VFSInfo_mediaType_set)
    __swig_setmethods__["reserved"] = _pisock.VFSInfo_reserved_set
    __swig_getmethods__["reserved"] = _pisock.VFSInfo_reserved_get
    if _newclass:reserved = property(_pisock.VFSInfo_reserved_get, _pisock.VFSInfo_reserved_set)
    def __init__(self, *args):
        _swig_setattr(self, VFSInfo, 'this', _pisock.new_VFSInfo(*args))
        _swig_setattr(self, VFSInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_VFSInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class VFSInfoPtr(VFSInfo):
    def __init__(self, this):
        _swig_setattr(self, VFSInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, VFSInfo, 'thisown', 0)
        self.__class__ = VFSInfo
_pisock.VFSInfo_swigregister(VFSInfoPtr)

class PilotUser(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PilotUser, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PilotUser, name)
    def __repr__(self):
        return "<%s.%s; proxy of C PilotUser instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["passwordLength"] = _pisock.PilotUser_passwordLength_set
    __swig_getmethods__["passwordLength"] = _pisock.PilotUser_passwordLength_get
    if _newclass:passwordLength = property(_pisock.PilotUser_passwordLength_get, _pisock.PilotUser_passwordLength_set)
    __swig_setmethods__["username"] = _pisock.PilotUser_username_set
    __swig_getmethods__["username"] = _pisock.PilotUser_username_get
    if _newclass:username = property(_pisock.PilotUser_username_get, _pisock.PilotUser_username_set)
    __swig_setmethods__["password"] = _pisock.PilotUser_password_set
    __swig_getmethods__["password"] = _pisock.PilotUser_password_get
    if _newclass:password = property(_pisock.PilotUser_password_get, _pisock.PilotUser_password_set)
    __swig_setmethods__["userID"] = _pisock.PilotUser_userID_set
    __swig_getmethods__["userID"] = _pisock.PilotUser_userID_get
    if _newclass:userID = property(_pisock.PilotUser_userID_get, _pisock.PilotUser_userID_set)
    __swig_setmethods__["viewerID"] = _pisock.PilotUser_viewerID_set
    __swig_getmethods__["viewerID"] = _pisock.PilotUser_viewerID_get
    if _newclass:viewerID = property(_pisock.PilotUser_viewerID_get, _pisock.PilotUser_viewerID_set)
    __swig_setmethods__["lastSyncPC"] = _pisock.PilotUser_lastSyncPC_set
    __swig_getmethods__["lastSyncPC"] = _pisock.PilotUser_lastSyncPC_get
    if _newclass:lastSyncPC = property(_pisock.PilotUser_lastSyncPC_get, _pisock.PilotUser_lastSyncPC_set)
    __swig_setmethods__["successfulSyncDate"] = _pisock.PilotUser_successfulSyncDate_set
    __swig_getmethods__["successfulSyncDate"] = _pisock.PilotUser_successfulSyncDate_get
    if _newclass:successfulSyncDate = property(_pisock.PilotUser_successfulSyncDate_get, _pisock.PilotUser_successfulSyncDate_set)
    __swig_setmethods__["lastSyncDate"] = _pisock.PilotUser_lastSyncDate_set
    __swig_getmethods__["lastSyncDate"] = _pisock.PilotUser_lastSyncDate_get
    if _newclass:lastSyncDate = property(_pisock.PilotUser_lastSyncDate_get, _pisock.PilotUser_lastSyncDate_set)
    def __init__(self, *args):
        _swig_setattr(self, PilotUser, 'this', _pisock.new_PilotUser(*args))
        _swig_setattr(self, PilotUser, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_PilotUser):
        try:
            if self.thisown: destroy(self)
        except: pass


class PilotUserPtr(PilotUser):
    def __init__(self, this):
        _swig_setattr(self, PilotUser, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, PilotUser, 'thisown', 0)
        self.__class__ = PilotUser
_pisock.PilotUser_swigregister(PilotUserPtr)

class SysInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SysInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SysInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C SysInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["romVersion"] = _pisock.SysInfo_romVersion_set
    __swig_getmethods__["romVersion"] = _pisock.SysInfo_romVersion_get
    if _newclass:romVersion = property(_pisock.SysInfo_romVersion_get, _pisock.SysInfo_romVersion_set)
    __swig_setmethods__["locale"] = _pisock.SysInfo_locale_set
    __swig_getmethods__["locale"] = _pisock.SysInfo_locale_get
    if _newclass:locale = property(_pisock.SysInfo_locale_get, _pisock.SysInfo_locale_set)
    __swig_setmethods__["prodIDLength"] = _pisock.SysInfo_prodIDLength_set
    __swig_getmethods__["prodIDLength"] = _pisock.SysInfo_prodIDLength_get
    if _newclass:prodIDLength = property(_pisock.SysInfo_prodIDLength_get, _pisock.SysInfo_prodIDLength_set)
    __swig_setmethods__["prodID"] = _pisock.SysInfo_prodID_set
    __swig_getmethods__["prodID"] = _pisock.SysInfo_prodID_get
    if _newclass:prodID = property(_pisock.SysInfo_prodID_get, _pisock.SysInfo_prodID_set)
    __swig_setmethods__["dlpMajorVersion"] = _pisock.SysInfo_dlpMajorVersion_set
    __swig_getmethods__["dlpMajorVersion"] = _pisock.SysInfo_dlpMajorVersion_get
    if _newclass:dlpMajorVersion = property(_pisock.SysInfo_dlpMajorVersion_get, _pisock.SysInfo_dlpMajorVersion_set)
    __swig_setmethods__["dlpMinorVersion"] = _pisock.SysInfo_dlpMinorVersion_set
    __swig_getmethods__["dlpMinorVersion"] = _pisock.SysInfo_dlpMinorVersion_get
    if _newclass:dlpMinorVersion = property(_pisock.SysInfo_dlpMinorVersion_get, _pisock.SysInfo_dlpMinorVersion_set)
    __swig_setmethods__["compatMajorVersion"] = _pisock.SysInfo_compatMajorVersion_set
    __swig_getmethods__["compatMajorVersion"] = _pisock.SysInfo_compatMajorVersion_get
    if _newclass:compatMajorVersion = property(_pisock.SysInfo_compatMajorVersion_get, _pisock.SysInfo_compatMajorVersion_set)
    __swig_setmethods__["compatMinorVersion"] = _pisock.SysInfo_compatMinorVersion_set
    __swig_getmethods__["compatMinorVersion"] = _pisock.SysInfo_compatMinorVersion_get
    if _newclass:compatMinorVersion = property(_pisock.SysInfo_compatMinorVersion_get, _pisock.SysInfo_compatMinorVersion_set)
    __swig_setmethods__["maxRecSize"] = _pisock.SysInfo_maxRecSize_set
    __swig_getmethods__["maxRecSize"] = _pisock.SysInfo_maxRecSize_get
    if _newclass:maxRecSize = property(_pisock.SysInfo_maxRecSize_get, _pisock.SysInfo_maxRecSize_set)
    def __init__(self, *args):
        _swig_setattr(self, SysInfo, 'this', _pisock.new_SysInfo(*args))
        _swig_setattr(self, SysInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_SysInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class SysInfoPtr(SysInfo):
    def __init__(self, this):
        _swig_setattr(self, SysInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, SysInfo, 'thisown', 0)
        self.__class__ = SysInfo
_pisock.SysInfo_swigregister(SysInfoPtr)

class DBInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DBInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DBInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C DBInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["more"] = _pisock.DBInfo_more_set
    __swig_getmethods__["more"] = _pisock.DBInfo_more_get
    if _newclass:more = property(_pisock.DBInfo_more_get, _pisock.DBInfo_more_set)
    __swig_setmethods__["name"] = _pisock.DBInfo_name_set
    __swig_getmethods__["name"] = _pisock.DBInfo_name_get
    if _newclass:name = property(_pisock.DBInfo_name_get, _pisock.DBInfo_name_set)
    __swig_setmethods__["flags"] = _pisock.DBInfo_flags_set
    __swig_getmethods__["flags"] = _pisock.DBInfo_flags_get
    if _newclass:flags = property(_pisock.DBInfo_flags_get, _pisock.DBInfo_flags_set)
    __swig_setmethods__["miscFlags"] = _pisock.DBInfo_miscFlags_set
    __swig_getmethods__["miscFlags"] = _pisock.DBInfo_miscFlags_get
    if _newclass:miscFlags = property(_pisock.DBInfo_miscFlags_get, _pisock.DBInfo_miscFlags_set)
    __swig_setmethods__["version"] = _pisock.DBInfo_version_set
    __swig_getmethods__["version"] = _pisock.DBInfo_version_get
    if _newclass:version = property(_pisock.DBInfo_version_get, _pisock.DBInfo_version_set)
    __swig_setmethods__["type"] = _pisock.DBInfo_type_set
    __swig_getmethods__["type"] = _pisock.DBInfo_type_get
    if _newclass:type = property(_pisock.DBInfo_type_get, _pisock.DBInfo_type_set)
    __swig_setmethods__["creator"] = _pisock.DBInfo_creator_set
    __swig_getmethods__["creator"] = _pisock.DBInfo_creator_get
    if _newclass:creator = property(_pisock.DBInfo_creator_get, _pisock.DBInfo_creator_set)
    __swig_setmethods__["modnum"] = _pisock.DBInfo_modnum_set
    __swig_getmethods__["modnum"] = _pisock.DBInfo_modnum_get
    if _newclass:modnum = property(_pisock.DBInfo_modnum_get, _pisock.DBInfo_modnum_set)
    __swig_setmethods__["index"] = _pisock.DBInfo_index_set
    __swig_getmethods__["index"] = _pisock.DBInfo_index_get
    if _newclass:index = property(_pisock.DBInfo_index_get, _pisock.DBInfo_index_set)
    __swig_setmethods__["createDate"] = _pisock.DBInfo_createDate_set
    __swig_getmethods__["createDate"] = _pisock.DBInfo_createDate_get
    if _newclass:createDate = property(_pisock.DBInfo_createDate_get, _pisock.DBInfo_createDate_set)
    __swig_setmethods__["modifyDate"] = _pisock.DBInfo_modifyDate_set
    __swig_getmethods__["modifyDate"] = _pisock.DBInfo_modifyDate_get
    if _newclass:modifyDate = property(_pisock.DBInfo_modifyDate_get, _pisock.DBInfo_modifyDate_set)
    __swig_setmethods__["backupDate"] = _pisock.DBInfo_backupDate_set
    __swig_getmethods__["backupDate"] = _pisock.DBInfo_backupDate_get
    if _newclass:backupDate = property(_pisock.DBInfo_backupDate_get, _pisock.DBInfo_backupDate_set)
    def __init__(self, *args):
        _swig_setattr(self, DBInfo, 'this', _pisock.new_DBInfo(*args))
        _swig_setattr(self, DBInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_DBInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class DBInfoPtr(DBInfo):
    def __init__(self, this):
        _swig_setattr(self, DBInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, DBInfo, 'thisown', 0)
        self.__class__ = DBInfo
_pisock.DBInfo_swigregister(DBInfoPtr)

class DBSizeInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DBSizeInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DBSizeInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C DBSizeInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["numRecords"] = _pisock.DBSizeInfo_numRecords_set
    __swig_getmethods__["numRecords"] = _pisock.DBSizeInfo_numRecords_get
    if _newclass:numRecords = property(_pisock.DBSizeInfo_numRecords_get, _pisock.DBSizeInfo_numRecords_set)
    __swig_setmethods__["totalBytes"] = _pisock.DBSizeInfo_totalBytes_set
    __swig_getmethods__["totalBytes"] = _pisock.DBSizeInfo_totalBytes_get
    if _newclass:totalBytes = property(_pisock.DBSizeInfo_totalBytes_get, _pisock.DBSizeInfo_totalBytes_set)
    __swig_setmethods__["dataBytes"] = _pisock.DBSizeInfo_dataBytes_set
    __swig_getmethods__["dataBytes"] = _pisock.DBSizeInfo_dataBytes_get
    if _newclass:dataBytes = property(_pisock.DBSizeInfo_dataBytes_get, _pisock.DBSizeInfo_dataBytes_set)
    __swig_setmethods__["appBlockSize"] = _pisock.DBSizeInfo_appBlockSize_set
    __swig_getmethods__["appBlockSize"] = _pisock.DBSizeInfo_appBlockSize_get
    if _newclass:appBlockSize = property(_pisock.DBSizeInfo_appBlockSize_get, _pisock.DBSizeInfo_appBlockSize_set)
    __swig_setmethods__["sortBlockSize"] = _pisock.DBSizeInfo_sortBlockSize_set
    __swig_getmethods__["sortBlockSize"] = _pisock.DBSizeInfo_sortBlockSize_get
    if _newclass:sortBlockSize = property(_pisock.DBSizeInfo_sortBlockSize_get, _pisock.DBSizeInfo_sortBlockSize_set)
    __swig_setmethods__["maxRecSize"] = _pisock.DBSizeInfo_maxRecSize_set
    __swig_getmethods__["maxRecSize"] = _pisock.DBSizeInfo_maxRecSize_get
    if _newclass:maxRecSize = property(_pisock.DBSizeInfo_maxRecSize_get, _pisock.DBSizeInfo_maxRecSize_set)
    def __init__(self, *args):
        _swig_setattr(self, DBSizeInfo, 'this', _pisock.new_DBSizeInfo(*args))
        _swig_setattr(self, DBSizeInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_DBSizeInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class DBSizeInfoPtr(DBSizeInfo):
    def __init__(self, this):
        _swig_setattr(self, DBSizeInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, DBSizeInfo, 'thisown', 0)
        self.__class__ = DBSizeInfo
_pisock.DBSizeInfo_swigregister(DBSizeInfoPtr)

class CardInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, CardInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, CardInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C CardInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["card"] = _pisock.CardInfo_card_set
    __swig_getmethods__["card"] = _pisock.CardInfo_card_get
    if _newclass:card = property(_pisock.CardInfo_card_get, _pisock.CardInfo_card_set)
    __swig_setmethods__["version"] = _pisock.CardInfo_version_set
    __swig_getmethods__["version"] = _pisock.CardInfo_version_get
    if _newclass:version = property(_pisock.CardInfo_version_get, _pisock.CardInfo_version_set)
    __swig_setmethods__["more"] = _pisock.CardInfo_more_set
    __swig_getmethods__["more"] = _pisock.CardInfo_more_get
    if _newclass:more = property(_pisock.CardInfo_more_get, _pisock.CardInfo_more_set)
    __swig_setmethods__["creation"] = _pisock.CardInfo_creation_set
    __swig_getmethods__["creation"] = _pisock.CardInfo_creation_get
    if _newclass:creation = property(_pisock.CardInfo_creation_get, _pisock.CardInfo_creation_set)
    __swig_setmethods__["romSize"] = _pisock.CardInfo_romSize_set
    __swig_getmethods__["romSize"] = _pisock.CardInfo_romSize_get
    if _newclass:romSize = property(_pisock.CardInfo_romSize_get, _pisock.CardInfo_romSize_set)
    __swig_setmethods__["ramSize"] = _pisock.CardInfo_ramSize_set
    __swig_getmethods__["ramSize"] = _pisock.CardInfo_ramSize_get
    if _newclass:ramSize = property(_pisock.CardInfo_ramSize_get, _pisock.CardInfo_ramSize_set)
    __swig_setmethods__["ramFree"] = _pisock.CardInfo_ramFree_set
    __swig_getmethods__["ramFree"] = _pisock.CardInfo_ramFree_get
    if _newclass:ramFree = property(_pisock.CardInfo_ramFree_get, _pisock.CardInfo_ramFree_set)
    __swig_setmethods__["name"] = _pisock.CardInfo_name_set
    __swig_getmethods__["name"] = _pisock.CardInfo_name_get
    if _newclass:name = property(_pisock.CardInfo_name_get, _pisock.CardInfo_name_set)
    __swig_setmethods__["manufacturer"] = _pisock.CardInfo_manufacturer_set
    __swig_getmethods__["manufacturer"] = _pisock.CardInfo_manufacturer_get
    if _newclass:manufacturer = property(_pisock.CardInfo_manufacturer_get, _pisock.CardInfo_manufacturer_set)
    def __init__(self, *args):
        _swig_setattr(self, CardInfo, 'this', _pisock.new_CardInfo(*args))
        _swig_setattr(self, CardInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_CardInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class CardInfoPtr(CardInfo):
    def __init__(self, this):
        _swig_setattr(self, CardInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, CardInfo, 'thisown', 0)
        self.__class__ = CardInfo
_pisock.CardInfo_swigregister(CardInfoPtr)

class NetSyncInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, NetSyncInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, NetSyncInfo, name)
    def __repr__(self):
        return "<%s.%s; proxy of C NetSyncInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
    __swig_setmethods__["lanSync"] = _pisock.NetSyncInfo_lanSync_set
    __swig_getmethods__["lanSync"] = _pisock.NetSyncInfo_lanSync_get
    if _newclass:lanSync = property(_pisock.NetSyncInfo_lanSync_get, _pisock.NetSyncInfo_lanSync_set)
    __swig_setmethods__["hostName"] = _pisock.NetSyncInfo_hostName_set
    __swig_getmethods__["hostName"] = _pisock.NetSyncInfo_hostName_get
    if _newclass:hostName = property(_pisock.NetSyncInfo_hostName_get, _pisock.NetSyncInfo_hostName_set)
    __swig_setmethods__["hostAddress"] = _pisock.NetSyncInfo_hostAddress_set
    __swig_getmethods__["hostAddress"] = _pisock.NetSyncInfo_hostAddress_get
    if _newclass:hostAddress = property(_pisock.NetSyncInfo_hostAddress_get, _pisock.NetSyncInfo_hostAddress_set)
    __swig_setmethods__["hostSubnetMask"] = _pisock.NetSyncInfo_hostSubnetMask_set
    __swig_getmethods__["hostSubnetMask"] = _pisock.NetSyncInfo_hostSubnetMask_get
    if _newclass:hostSubnetMask = property(_pisock.NetSyncInfo_hostSubnetMask_get, _pisock.NetSyncInfo_hostSubnetMask_set)
    def __init__(self, *args):
        _swig_setattr(self, NetSyncInfo, 'this', _pisock.new_NetSyncInfo(*args))
        _swig_setattr(self, NetSyncInfo, 'thisown', 1)
    def __del__(self, destroy=_pisock.delete_NetSyncInfo):
        try:
            if self.thisown: destroy(self)
        except: pass


class NetSyncInfoPtr(NetSyncInfo):
    def __init__(self, this):
        _swig_setattr(self, NetSyncInfo, 'this', this)
        if not hasattr(self,"thisown"): _swig_setattr(self, NetSyncInfo, 'thisown', 0)
        self.__class__ = NetSyncInfo
_pisock.NetSyncInfo_swigregister(NetSyncInfoPtr)

dlpDBFlagResource = _pisock.dlpDBFlagResource
dlpDBFlagReadOnly = _pisock.dlpDBFlagReadOnly
dlpDBFlagAppInfoDirty = _pisock.dlpDBFlagAppInfoDirty
dlpDBFlagBackup = _pisock.dlpDBFlagBackup
dlpDBFlagHidden = _pisock.dlpDBFlagHidden
dlpDBFlagLaunchable = _pisock.dlpDBFlagLaunchable
dlpDBFlagRecyclable = _pisock.dlpDBFlagRecyclable
dlpDBFlagBundle = _pisock.dlpDBFlagBundle
dlpDBFlagOpen = _pisock.dlpDBFlagOpen
dlpDBFlagNewer = _pisock.dlpDBFlagNewer
dlpDBFlagReset = _pisock.dlpDBFlagReset
dlpDBFlagCopyPrevention = _pisock.dlpDBFlagCopyPrevention
dlpDBFlagStream = _pisock.dlpDBFlagStream
dlpDBFlagSchema = _pisock.dlpDBFlagSchema
dlpDBFlagSecure = _pisock.dlpDBFlagSecure
dlpDBFlagExtended = _pisock.dlpDBFlagExtended
dlpDBFlagFixedUp = _pisock.dlpDBFlagFixedUp
dlpDBMiscFlagExcludeFromSync = _pisock.dlpDBMiscFlagExcludeFromSync
dlpDBMiscFlagRamBased = _pisock.dlpDBMiscFlagRamBased
dlpRecAttrDeleted = _pisock.dlpRecAttrDeleted
dlpRecAttrDirty = _pisock.dlpRecAttrDirty
dlpRecAttrBusy = _pisock.dlpRecAttrBusy
dlpRecAttrSecret = _pisock.dlpRecAttrSecret
dlpRecAttrArchived = _pisock.dlpRecAttrArchived
dlpOpenRead = _pisock.dlpOpenRead
dlpOpenWrite = _pisock.dlpOpenWrite
dlpOpenExclusive = _pisock.dlpOpenExclusive
dlpOpenSecret = _pisock.dlpOpenSecret
dlpOpenReadWrite = _pisock.dlpOpenReadWrite
dlpDBListRAM = _pisock.dlpDBListRAM
dlpDBListROM = _pisock.dlpDBListROM
dlpDBListMultiple = _pisock.dlpDBListMultiple
dlpFindDBOptFlagGetAttributes = _pisock.dlpFindDBOptFlagGetAttributes
dlpFindDBOptFlagGetSize = _pisock.dlpFindDBOptFlagGetSize
dlpFindDBOptFlagMaxRecSize = _pisock.dlpFindDBOptFlagMaxRecSize
dlpFindDBSrchFlagNewSearch = _pisock.dlpFindDBSrchFlagNewSearch
dlpFindDBSrchFlagOnlyLatest = _pisock.dlpFindDBSrchFlagOnlyLatest
dlpEndCodeNormal = _pisock.dlpEndCodeNormal
dlpEndCodeOutOfMemory = _pisock.dlpEndCodeOutOfMemory
dlpEndCodeUserCan = _pisock.dlpEndCodeUserCan
dlpEndCodeOther = _pisock.dlpEndCodeOther
dlpExpCapabilityHasStorage = _pisock.dlpExpCapabilityHasStorage
dlpExpCapabilityReadOnly = _pisock.dlpExpCapabilityReadOnly
dlpExpCapabilitySerial = _pisock.dlpExpCapabilitySerial
vfsVolAttrSlotBased = _pisock.vfsVolAttrSlotBased
vfsVolAttrReadOnly = _pisock.vfsVolAttrReadOnly
vfsVolAttrHidden = _pisock.vfsVolAttrHidden
vfsOriginBeginning = _pisock.vfsOriginBeginning
vfsOriginCurrent = _pisock.vfsOriginCurrent
vfsOriginEnd = _pisock.vfsOriginEnd
dlpVFSOpenExclusive = _pisock.dlpVFSOpenExclusive
dlpVFSOpenRead = _pisock.dlpVFSOpenRead
dlpVFSOpenWrite = _pisock.dlpVFSOpenWrite
dlpVFSOpenReadWrite = _pisock.dlpVFSOpenReadWrite
vfsModeExclusive = _pisock.vfsModeExclusive
vfsModeRead = _pisock.vfsModeRead
vfsModeWrite = _pisock.vfsModeWrite
vfsModeReadWrite = _pisock.vfsModeReadWrite
vfsModeCreate = _pisock.vfsModeCreate
vfsModeTruncate = _pisock.vfsModeTruncate
vfsModeLeaveOpen = _pisock.vfsModeLeaveOpen
vfsFileAttrReadOnly = _pisock.vfsFileAttrReadOnly
vfsFileAttrHidden = _pisock.vfsFileAttrHidden
vfsFileAttrSystem = _pisock.vfsFileAttrSystem
vfsFileAttrVolumeLabel = _pisock.vfsFileAttrVolumeLabel
vfsFileAttrDirectory = _pisock.vfsFileAttrDirectory
vfsFileAttrArchive = _pisock.vfsFileAttrArchive
vfsFileAttrLink = _pisock.vfsFileAttrLink
vfsFileDateCreated = _pisock.vfsFileDateCreated
vfsFileDateModified = _pisock.vfsFileDateModified
vfsFileDateAccessed = _pisock.vfsFileDateAccessed
vfsIteratorStart = _pisock.vfsIteratorStart
vfsIteratorStop = _pisock.vfsIteratorStop
dlpErrNoError = _pisock.dlpErrNoError
dlpErrSystem = _pisock.dlpErrSystem
dlpErrIllegalReq = _pisock.dlpErrIllegalReq
dlpErrMemory = _pisock.dlpErrMemory
dlpErrParam = _pisock.dlpErrParam
dlpErrNotFound = _pisock.dlpErrNotFound
dlpErrNoneOpen = _pisock.dlpErrNoneOpen
dlpErrAlreadyOpen = _pisock.dlpErrAlreadyOpen
dlpErrTooManyOpen = _pisock.dlpErrTooManyOpen
dlpErrExists = _pisock.dlpErrExists
dlpErrOpen = _pisock.dlpErrOpen
dlpErrDeleted = _pisock.dlpErrDeleted
dlpErrBusy = _pisock.dlpErrBusy
dlpErrNotSupp = _pisock.dlpErrNotSupp
dlpErrUnused1 = _pisock.dlpErrUnused1
dlpErrReadOnly = _pisock.dlpErrReadOnly
dlpErrSpace = _pisock.dlpErrSpace
dlpErrLimit = _pisock.dlpErrLimit
dlpErrSync = _pisock.dlpErrSync
dlpErrWrapper = _pisock.dlpErrWrapper
dlpErrArgument = _pisock.dlpErrArgument
dlpErrSize = _pisock.dlpErrSize
dlpErrUnknown = _pisock.dlpErrUnknown

dlp_set_protocol_version = _pisock.dlp_set_protocol_version

dlp_ptohdate = _pisock.dlp_ptohdate

dlp_htopdate = _pisock.dlp_htopdate

dlp_GetSysDateTime_ = _pisock.dlp_GetSysDateTime_

dlp_SetSysDateTime = _pisock.dlp_SetSysDateTime

dlp_ReadSysInfo = _pisock.dlp_ReadSysInfo

dlp_ReadStorageInfo = _pisock.dlp_ReadStorageInfo

dlp_ReadUserInfo = _pisock.dlp_ReadUserInfo

dlp_WriteUserInfo = _pisock.dlp_WriteUserInfo

dlp_ResetLastSyncPC = _pisock.dlp_ResetLastSyncPC

dlp_ReadNetSyncInfo = _pisock.dlp_ReadNetSyncInfo

dlp_WriteNetSyncInfo = _pisock.dlp_WriteNetSyncInfo

dlp_OpenConduit = _pisock.dlp_OpenConduit

dlp_EndOfSync = _pisock.dlp_EndOfSync

dlp_AbortSync = _pisock.dlp_AbortSync

dlp_ReadFeature = _pisock.dlp_ReadFeature

dlp_GetROMToken = _pisock.dlp_GetROMToken

dlp_AddSyncLogEntry = _pisock.dlp_AddSyncLogEntry

dlp_CallApplication = _pisock.dlp_CallApplication

dlp_ReadAppPreference = _pisock.dlp_ReadAppPreference

dlp_WriteAppPreference = _pisock.dlp_WriteAppPreference

dlp_ResetSystem = _pisock.dlp_ResetSystem

dlp_ReadDBList_ = _pisock.dlp_ReadDBList_

dlp_FindDBByName = _pisock.dlp_FindDBByName

dlp_FindDBByOpenHandle = _pisock.dlp_FindDBByOpenHandle

dlp_FindDBByTypeCreator = _pisock.dlp_FindDBByTypeCreator

dlp_FindDBInfo = _pisock.dlp_FindDBInfo

dlp_OpenDB = _pisock.dlp_OpenDB

dlp_CloseDB = _pisock.dlp_CloseDB

dlp_CloseDB_All = _pisock.dlp_CloseDB_All

dlp_DeleteDB = _pisock.dlp_DeleteDB

dlp_CreateDB = _pisock.dlp_CreateDB

dlp_ReadOpenDBInfo = _pisock.dlp_ReadOpenDBInfo

dlp_SetDBInfo = _pisock.dlp_SetDBInfo

dlp_DeleteCategory = _pisock.dlp_DeleteCategory

dlp_MoveCategory = _pisock.dlp_MoveCategory

dlp_ReadAppBlock = _pisock.dlp_ReadAppBlock

dlp_WriteAppBlock = _pisock.dlp_WriteAppBlock

dlp_ReadSortBlock = _pisock.dlp_ReadSortBlock

dlp_WriteSortBlock = _pisock.dlp_WriteSortBlock

dlp_CleanUpDatabase = _pisock.dlp_CleanUpDatabase

dlp_ResetSyncFlags = _pisock.dlp_ResetSyncFlags

dlp_ResetDBIndex = _pisock.dlp_ResetDBIndex

dlp_ReadRecordById = _pisock.dlp_ReadRecordById

dlp_ReadRecordByIndex = _pisock.dlp_ReadRecordByIndex

dlp_ReadNextModifiedRec = _pisock.dlp_ReadNextModifiedRec

dlp_ReadNextModifiedRecInCategory = _pisock.dlp_ReadNextModifiedRecInCategory

dlp_ReadNextRecInCategory = _pisock.dlp_ReadNextRecInCategory

dlp_WriteRecord = _pisock.dlp_WriteRecord

dlp_DeleteRecord = _pisock.dlp_DeleteRecord

dlp_ReadResourceByType = _pisock.dlp_ReadResourceByType

dlp_ReadResourceByIndex = _pisock.dlp_ReadResourceByIndex

dlp_WriteResource = _pisock.dlp_WriteResource

dlp_DeleteResource = _pisock.dlp_DeleteResource

dlp_ExpSlotEnumerate = _pisock.dlp_ExpSlotEnumerate

dlp_ExpCardPresent = _pisock.dlp_ExpCardPresent

dlp_ExpCardInfo = _pisock.dlp_ExpCardInfo

dlp_ExpSlotMediaType = _pisock.dlp_ExpSlotMediaType

dlp_VFSVolumeEnumerate = _pisock.dlp_VFSVolumeEnumerate

dlp_VFSVolumeInfo = _pisock.dlp_VFSVolumeInfo

dlp_VFSVolumeGetLabel = _pisock.dlp_VFSVolumeGetLabel

dlp_VFSVolumeSetLabel = _pisock.dlp_VFSVolumeSetLabel

dlp_VFSVolumeSize = _pisock.dlp_VFSVolumeSize

dlp_VFSVolumeFormat = _pisock.dlp_VFSVolumeFormat

dlp_VFSGetDefaultDir = _pisock.dlp_VFSGetDefaultDir

dlp_VFSDirEntryEnumerate = _pisock.dlp_VFSDirEntryEnumerate

dlp_VFSDirCreate = _pisock.dlp_VFSDirCreate

dlp_VFSImportDatabaseFromFile = _pisock.dlp_VFSImportDatabaseFromFile

dlp_VFSExportDatabaseToFile = _pisock.dlp_VFSExportDatabaseToFile

dlp_VFSFileCreate = _pisock.dlp_VFSFileCreate

dlp_VFSFileOpen = _pisock.dlp_VFSFileOpen

dlp_VFSFileClose = _pisock.dlp_VFSFileClose

dlp_VFSFileWrite = _pisock.dlp_VFSFileWrite

dlp_VFSFileRead = _pisock.dlp_VFSFileRead

dlp_VFSFileDelete = _pisock.dlp_VFSFileDelete

dlp_VFSFileRename = _pisock.dlp_VFSFileRename

dlp_VFSFileEOF = _pisock.dlp_VFSFileEOF

dlp_VFSFileTell = _pisock.dlp_VFSFileTell

dlp_VFSFileGetAttributes = _pisock.dlp_VFSFileGetAttributes

dlp_VFSFileSetAttributes = _pisock.dlp_VFSFileSetAttributes

dlp_VFSFileGetDate = _pisock.dlp_VFSFileGetDate

dlp_VFSFileSetDate = _pisock.dlp_VFSFileSetDate

dlp_VFSFileSeek = _pisock.dlp_VFSFileSeek

dlp_VFSFileResize = _pisock.dlp_VFSFileResize

dlp_VFSFileSize = _pisock.dlp_VFSFileSize