f2f5aec6c46ff59052a45d4ed5d6cb361efbdb4d
[samba.git] / source3 / libsmb / libsmb_setget.c
1 /* 
2    Unix SMB/Netbios implementation.
3    SMB client library implementation
4    Copyright (C) Andrew Tridgell 1998
5    Copyright (C) Richard Sharpe 2000, 2002
6    Copyright (C) John Terpstra 2000
7    Copyright (C) Tom Jansen (Ninja ISD) 2002 
8    Copyright (C) Derrell Lipman 2003-2008
9    Copyright (C) Jeremy Allison 2007, 2008
10
11    This program is free software; you can redistribute it and/or modify
12    it under the terms of the GNU General Public License as published by
13    the Free Software Foundation; either version 3 of the License, or
14    (at your option) any later version.
15
16    This program is distributed in the hope that it will be useful,
17    but WITHOUT ANY WARRANTY; without even the implied warranty of
18    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19    GNU General Public License for more details.
20
21    You should have received a copy of the GNU General Public License
22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
23 */
24
25 #include "includes.h"
26 #define __LIBSMBCLIENT_INTERNAL__
27 #include "libsmbclient.h"
28 #include "libsmb_internal.h"
29
30
31 /** Get the netbios name used for making connections */
32 char *
33 smbc_getNetbiosName(SMBCCTX *c)
34 {
35         return c->netbios_name;
36 }
37
38 /** Set the netbios name used for making connections */
39 void
40 smbc_setNetbiosName(SMBCCTX *c, char * netbios_name)
41 {
42         SAFE_FREE(c->netbios_name);
43         if (netbios_name) {
44                 c->netbios_name = SMB_STRDUP(netbios_name);
45         }
46 }
47
48 /** Get the workgroup used for making connections */
49 char *
50 smbc_getWorkgroup(SMBCCTX *c)
51 {
52         return c->workgroup;
53 }
54
55 /** Set the workgroup used for making connections */
56 void
57 smbc_setWorkgroup(SMBCCTX *c, char * workgroup)
58 {
59         SAFE_FREE(c->workgroup);
60         if (workgroup) {
61                 c->workgroup = SMB_STRDUP(workgroup);
62         }
63 }
64
65 /** Get the username used for making connections */
66 char *
67 smbc_getUser(SMBCCTX *c)
68 {
69         return c->user;
70 }
71
72 /** Set the username used for making connections */
73 void
74 smbc_setUser(SMBCCTX *c, char * user)
75 {
76         SAFE_FREE(c->user);
77         if (user) {
78                 c->user = SMB_STRDUP(user);
79         }
80 }
81
82 /** Get the debug level */
83 int
84 smbc_getDebug(SMBCCTX *c)
85 {
86         return c->debug;
87 }
88
89 /** Set the debug level */
90 void
91 smbc_setDebug(SMBCCTX *c, int debug)
92 {
93         char buf[32];
94         snprintf(buf, sizeof(buf), "%d", debug);
95         c->debug = debug;
96         lp_set_cmdline("log level", buf); 
97 }
98
99 /**
100  * Get the timeout used for waiting on connections and response data
101  * (in milliseconds)
102  */
103 int
104 smbc_getTimeout(SMBCCTX *c)
105 {
106         return c->timeout;
107 }
108
109 /**
110  * Set the timeout used for waiting on connections and response data
111  * (in milliseconds)
112  */
113 void
114 smbc_setTimeout(SMBCCTX *c, int timeout)
115 {
116         c->timeout = timeout;
117 }
118
119 /** Get whether to log to standard error instead of standard output */
120 smbc_bool
121 smbc_getOptionDebugToStderr(SMBCCTX *c)
122 {
123         return c->internal->debug_stderr;
124 }
125
126 /** Set whether to log to standard error instead of standard output */
127 void
128 smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b)
129 {
130         c->internal->debug_stderr = b;
131 }
132
133 /**
134  * Get whether to use new-style time attribute names, e.g. WRITE_TIME rather
135  * than the old-style names such as M_TIME.  This allows also setting/getting
136  * CREATE_TIME which was previously unimplemented.  (Note that the old C_TIME
137  * was supposed to be CHANGE_TIME but was confused and sometimes referred to
138  * CREATE_TIME.)
139  */
140 smbc_bool
141 smbc_getOptionFullTimeNames(SMBCCTX *c)
142 {
143         return c->internal->full_time_names;
144 }
145
146 /**
147  * Set whether to use new-style time attribute names, e.g. WRITE_TIME rather
148  * than the old-style names such as M_TIME.  This allows also setting/getting
149  * CREATE_TIME which was previously unimplemented.  (Note that the old C_TIME
150  * was supposed to be CHANGE_TIME but was confused and sometimes referred to
151  * CREATE_TIME.)
152  */
153 void
154 smbc_setOptionFullTimeNames(SMBCCTX *c, smbc_bool b)
155 {
156         c->internal->full_time_names = b;
157 }
158
159 /**
160  * Get the share mode to use for files opened with SMBC_open_ctx().  The
161  * default is SMBC_SHAREMODE_DENY_NONE.
162  */
163 smbc_share_mode
164 smbc_getOptionOpenShareMode(SMBCCTX *c)
165 {
166         return c->internal->share_mode;
167 }
168
169 /**
170  * Set the share mode to use for files opened with SMBC_open_ctx().  The
171  * default is SMBC_SHAREMODE_DENY_NONE.
172  */
173 void
174 smbc_setOptionOpenShareMode(SMBCCTX *c, smbc_share_mode share_mode)
175 {
176         c->internal->share_mode = share_mode;
177 }
178
179 /** Retrieve a previously set user data handle */
180 void *
181 smbc_getOptionUserData(SMBCCTX *c)
182 {
183         return c->internal->user_data;
184 }
185
186 /** Save a user data handle */
187 void
188 smbc_setOptionUserData(SMBCCTX *c, void *user_data)
189 {
190         c->internal->user_data = user_data;
191 }
192
193 /** Get the encoded value for encryption level. */
194 smbc_smb_encrypt_level
195 smbc_getOptionSmbEncryptionLevel(SMBCCTX *c)
196 {
197         return c->internal->smb_encryption_level;
198 }
199
200 /** Set the encoded value for encryption level. */
201 void
202 smbc_setOptionSmbEncryptionLevel(SMBCCTX *c, smbc_smb_encrypt_level level)
203 {
204         c->internal->smb_encryption_level = level;
205 }
206
207 /**
208  * Get whether to treat file names as case-sensitive if we can't determine
209  * when connecting to the remote share whether the file system is case
210  * sensitive. This defaults to FALSE since it's most likely that if we can't
211  * retrieve the file system attributes, it's a very old file system that does
212  * not support case sensitivity.
213  */
214 smbc_bool
215 smbc_getOptionCaseSensitive(SMBCCTX *c)
216 {
217         return c->internal->case_sensitive;
218 }
219
220 /**
221  * Set whether to treat file names as case-sensitive if we can't determine
222  * when connecting to the remote share whether the file system is case
223  * sensitive. This defaults to FALSE since it's most likely that if we can't
224  * retrieve the file system attributes, it's a very old file system that does
225  * not support case sensitivity.
226  */
227 void
228 smbc_setOptionCaseSensitive(SMBCCTX *c, smbc_bool b)
229 {
230         c->internal->case_sensitive = b;
231 }
232
233 /**
234  * Get from how many local master browsers should the list of workgroups be
235  * retrieved.  It can take up to 12 minutes or longer after a server becomes a
236  * local master browser, for it to have the entire browse list (the list of
237  * workgroups/domains) from an entire network.  Since a client never knows
238  * which local master browser will be found first, the one which is found
239  * first and used to retrieve a browse list may have an incomplete or empty
240  * browse list.  By requesting the browse list from multiple local master
241  * browsers, a more complete list can be generated.  For small networks (few
242  * workgroups), it is recommended that this value be set to 0, causing the
243  * browse lists from all found local master browsers to be retrieved and
244  * merged.  For networks with many workgroups, a suitable value for this
245  * variable is probably somewhere around 3. (Default: 3).
246  */
247 int
248 smbc_getOptionBrowseMaxLmbCount(SMBCCTX *c)
249 {
250         return c->options.browse_max_lmb_count;
251 }
252
253 /**
254  * Set from how many local master browsers should the list of workgroups be
255  * retrieved.  It can take up to 12 minutes or longer after a server becomes a
256  * local master browser, for it to have the entire browse list (the list of
257  * workgroups/domains) from an entire network.  Since a client never knows
258  * which local master browser will be found first, the one which is found
259  * first and used to retrieve a browse list may have an incomplete or empty
260  * browse list.  By requesting the browse list from multiple local master
261  * browsers, a more complete list can be generated.  For small networks (few
262  * workgroups), it is recommended that this value be set to 0, causing the
263  * browse lists from all found local master browsers to be retrieved and
264  * merged.  For networks with many workgroups, a suitable value for this
265  * variable is probably somewhere around 3. (Default: 3).
266  */
267 void
268 smbc_setOptionBrowseMaxLmbCount(SMBCCTX *c, int count)
269 {
270         c->options.browse_max_lmb_count = count;
271 }
272
273 /**
274  * Get whether to url-encode readdir entries.
275  *
276  * There is a difference in the desired return strings from
277  * smbc_readdir() depending upon whether the filenames are to
278  * be displayed to the user, or whether they are to be
279  * appended to the path name passed to smbc_opendir() to call
280  * a further smbc_ function (e.g. open the file with
281  * smbc_open()).  In the former case, the filename should be
282  * in "human readable" form.  In the latter case, the smbc_
283  * functions expect a URL which must be url-encoded.  Those
284  * functions decode the URL.  If, for example, smbc_readdir()
285  * returned a file name of "abc%20def.txt", passing a path
286  * with this file name attached to smbc_open() would cause
287  * smbc_open to attempt to open the file "abc def.txt" since
288  * the %20 is decoded into a space.
289  *
290  * Set this option to True if the names returned by
291  * smbc_readdir() should be url-encoded such that they can be
292  * passed back to another smbc_ call.  Set it to False if the
293  * names returned by smbc_readdir() are to be presented to the
294  * user.
295  *
296  * For backwards compatibility, this option defaults to False.
297  */
298 smbc_bool
299 smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX *c)
300 {
301         return c->options.urlencode_readdir_entries;
302 }
303
304 /**
305  * Set whether to url-encode readdir entries.
306  *
307  * There is a difference in the desired return strings from
308  * smbc_readdir() depending upon whether the filenames are to
309  * be displayed to the user, or whether they are to be
310  * appended to the path name passed to smbc_opendir() to call
311  * a further smbc_ function (e.g. open the file with
312  * smbc_open()).  In the former case, the filename should be
313  * in "human readable" form.  In the latter case, the smbc_
314  * functions expect a URL which must be url-encoded.  Those
315  * functions decode the URL.  If, for example, smbc_readdir()
316  * returned a file name of "abc%20def.txt", passing a path
317  * with this file name attached to smbc_open() would cause
318  * smbc_open to attempt to open the file "abc def.txt" since
319  * the %20 is decoded into a space.
320  *
321  * Set this option to True if the names returned by
322  * smbc_readdir() should be url-encoded such that they can be
323  * passed back to another smbc_ call.  Set it to False if the
324  * names returned by smbc_readdir() are to be presented to the
325  * user.
326  *
327  * For backwards compatibility, this option defaults to False.
328  */
329 void
330 smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX *c, smbc_bool b)
331 {
332         c->options.urlencode_readdir_entries = b;
333 }
334
335 /**
336  * Get whether to use the same connection for all shares on a server.
337  *
338  * Some Windows versions appear to have a limit to the number
339  * of concurrent SESSIONs and/or TREE CONNECTions.  In
340  * one-shot programs (i.e. the program runs and then quickly
341  * ends, thereby shutting down all connections), it is
342  * probably reasonable to establish a new connection for each
343  * share.  In long-running applications, the limitation can be
344  * avoided by using only a single connection to each server,
345  * and issuing a new TREE CONNECT when the share is accessed.
346  */
347 smbc_bool
348 smbc_getOptionOneSharePerServer(SMBCCTX *c)
349 {
350         return c->options.one_share_per_server;
351 }
352
353 /**
354  * Set whether to use the same connection for all shares on a server.
355  *
356  * Some Windows versions appear to have a limit to the number
357  * of concurrent SESSIONs and/or TREE CONNECTions.  In
358  * one-shot programs (i.e. the program runs and then quickly
359  * ends, thereby shutting down all connections), it is
360  * probably reasonable to establish a new connection for each
361  * share.  In long-running applications, the limitation can be
362  * avoided by using only a single connection to each server,
363  * and issuing a new TREE CONNECT when the share is accessed.
364  */
365 void
366 smbc_setOptionOneSharePerServer(SMBCCTX *c, smbc_bool b)
367 {
368         c->options.one_share_per_server = b;
369 }
370
371 /** Get whether to enable use of kerberos */
372 smbc_bool
373 smbc_getOptionUseKerberos(SMBCCTX *c)
374 {
375         return c->flags & SMB_CTX_FLAG_USE_KERBEROS ? True : False;
376 }
377
378 /** Set whether to enable use of kerberos */
379 void
380 smbc_setOptionUseKerberos(SMBCCTX *c, smbc_bool b)
381 {
382         if (b) {
383                 c->flags |= SMB_CTX_FLAG_USE_KERBEROS;
384         } else {
385                 c->flags &= ~SMB_CTX_FLAG_USE_KERBEROS;
386         }
387 }
388
389 /** Get whether to fallback after kerberos */
390 smbc_bool
391 smbc_getOptionFallbackAfterKerberos(SMBCCTX *c)
392 {
393         return c->flags & SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS ? True : False;
394 }
395
396 /** Set whether to fallback after kerberos */
397 void
398 smbc_setOptionFallbackAfterKerberos(SMBCCTX *c, smbc_bool b)
399 {
400         if (b) {
401                 c->flags |= SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
402         } else {
403                 c->flags &= ~SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
404         }
405 }
406
407 /** Get whether to automatically select anonymous login */
408 smbc_bool
409 smbc_getOptionNoAutoAnonymousLogin(SMBCCTX *c)
410 {
411         return c->flags & SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON ? True : False;
412 }
413
414 /** Set whether to automatically select anonymous login */
415 void
416 smbc_setOptionNoAutoAnonymousLogin(SMBCCTX *c, smbc_bool b)
417 {
418         if (b) {
419                 c->flags |= SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
420         } else {
421                 c->flags &= ~SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
422         }
423 }
424
425 /** Get whether to enable use of kerberos */
426 smbc_bool
427 smbc_getOptionUseCCache(SMBCCTX *c)
428 {
429         return c->flags & SMB_CTX_FLAG_USE_CCACHE ? True : False;
430 }
431
432 /** Set whether to enable use of kerberos */
433 void
434 smbc_setOptionUseCCache(SMBCCTX *c, smbc_bool b)
435 {
436         if (b) {
437                 c->flags |= SMB_CTX_FLAG_USE_CCACHE;
438         } else {
439                 c->flags &= ~SMB_CTX_FLAG_USE_CCACHE;
440         }
441 }
442
443 /** Get the function for obtaining authentication data */
444 smbc_get_auth_data_fn
445 smbc_getFunctionAuthData(SMBCCTX *c)
446 {
447         return c->callbacks.auth_fn;
448 }
449
450 /** Set the function for obtaining authentication data */
451 void
452 smbc_setFunctionAuthData(SMBCCTX *c, smbc_get_auth_data_fn fn)
453 {
454         c->internal->auth_fn_with_context = NULL;
455         c->callbacks.auth_fn = fn;
456 }
457
458 /** Get the new-style authentication function which includes the context. */
459 smbc_get_auth_data_with_context_fn
460 smbc_getFunctionAuthDataWithContext(SMBCCTX *c)
461 {
462         return c->internal->auth_fn_with_context;
463 }
464
465 /** Set the new-style authentication function which includes the context. */
466 void
467 smbc_setFunctionAuthDataWithContext(SMBCCTX *c,
468                                     smbc_get_auth_data_with_context_fn fn)
469 {
470         c->callbacks.auth_fn = NULL;
471         c->internal->auth_fn_with_context = fn;
472 }
473
474 /** Get the function for checking if a server is still good */
475 smbc_check_server_fn
476 smbc_getFunctionCheckServer(SMBCCTX *c)
477 {
478         return c->callbacks.check_server_fn;
479 }
480
481 /** Set the function for checking if a server is still good */
482 void
483 smbc_setFunctionCheckServer(SMBCCTX *c, smbc_check_server_fn fn)
484 {
485         c->callbacks.check_server_fn = fn;
486 }
487
488 /** Get the function for removing a server if unused */
489 smbc_remove_unused_server_fn
490 smbc_getFunctionRemoveUnusedServer(SMBCCTX *c)
491 {
492         return c->callbacks.remove_unused_server_fn;
493 }
494
495 /** Set the function for removing a server if unused */
496 void
497 smbc_setFunctionRemoveUnusedServer(SMBCCTX *c,
498                                    smbc_remove_unused_server_fn fn)
499 {
500         c->callbacks.remove_unused_server_fn = fn;
501 }
502
503 /** Get the function for adding a cached server */
504 smbc_add_cached_srv_fn
505 smbc_getFunctionAddCachedServer(SMBCCTX *c)
506 {
507         return c->callbacks.add_cached_srv_fn;
508 }
509
510 /** Set the function for adding a cached server */
511 void
512 smbc_setFunctionAddCachedServer(SMBCCTX *c, smbc_add_cached_srv_fn fn)
513 {
514         c->callbacks.add_cached_srv_fn = fn;
515 }
516
517 /** Get the function for server cache lookup */
518 smbc_get_cached_srv_fn
519 smbc_getFunctionGetCachedServer(SMBCCTX *c)
520 {
521         return c->callbacks.get_cached_srv_fn;
522 }
523
524 /** Set the function for server cache lookup */
525 void
526 smbc_setFunctionGetCachedServer(SMBCCTX *c, smbc_get_cached_srv_fn fn)
527 {
528         c->callbacks.get_cached_srv_fn = fn;
529 }
530
531 /** Get the function for server cache removal */
532 smbc_remove_cached_srv_fn
533 smbc_getFunctionRemoveCachedServer(SMBCCTX *c)
534 {
535         return c->callbacks.remove_cached_srv_fn;
536 }
537
538 /** Set the function for server cache removal */
539 void
540 smbc_setFunctionRemoveCachedServer(SMBCCTX *c,
541                                    smbc_remove_cached_srv_fn fn)
542 {
543         c->callbacks.remove_cached_srv_fn = fn;
544 }
545
546 /**
547  * Get the function for server cache purging.  This function tries to
548  * remove all cached servers (e.g. on disconnect)
549  */
550 smbc_purge_cached_fn
551 smbc_getFunctionPurgeCachedServers(SMBCCTX *c)
552 {
553         return c->callbacks.purge_cached_fn;
554 }
555
556 /** Set the function to store private data of the server cache */
557 void smbc_setServerCacheData(SMBCCTX *c, struct smbc_server_cache * cache)
558 {
559         c->internal->server_cache = cache;
560 }
561
562 /** Get the function to store private data of the server cache */
563 struct smbc_server_cache * smbc_getServerCacheData(SMBCCTX *c)
564 {
565         return c->internal->server_cache;
566 }
567
568
569 /**
570  * Set the function for server cache purging.  This function tries to
571  * remove all cached servers (e.g. on disconnect)
572  */
573 void
574 smbc_setFunctionPurgeCachedServers(SMBCCTX *c, smbc_purge_cached_fn fn)
575 {
576         c->callbacks.purge_cached_fn = fn;
577 }
578
579 /**
580  * Callable functions for files.
581  */
582
583 smbc_open_fn
584 smbc_getFunctionOpen(SMBCCTX *c)
585 {
586         return c->open;
587 }
588
589 void
590 smbc_setFunctionOpen(SMBCCTX *c, smbc_open_fn fn)
591 {
592         c->open = fn;
593 }
594
595 smbc_creat_fn
596 smbc_getFunctionCreat(SMBCCTX *c)
597 {
598         return c->creat;
599 }
600
601 void
602 smbc_setFunctionCreat(SMBCCTX *c, smbc_creat_fn fn)
603 {
604         c->creat = fn;
605 }
606
607 smbc_read_fn
608 smbc_getFunctionRead(SMBCCTX *c)
609 {
610         return c->read;
611 }
612
613 void
614 smbc_setFunctionRead(SMBCCTX *c, smbc_read_fn fn)
615 {
616         c->read = fn;
617 }
618
619 smbc_write_fn
620 smbc_getFunctionWrite(SMBCCTX *c)
621 {
622         return c->write;
623 }
624
625 void
626 smbc_setFunctionWrite(SMBCCTX *c, smbc_write_fn fn)
627 {
628         c->write = fn;
629 }
630
631 smbc_unlink_fn
632 smbc_getFunctionUnlink(SMBCCTX *c)
633 {
634         return c->unlink;
635 }
636
637 void
638 smbc_setFunctionUnlink(SMBCCTX *c, smbc_unlink_fn fn)
639 {
640         c->unlink = fn;
641 }
642
643 smbc_rename_fn
644 smbc_getFunctionRename(SMBCCTX *c)
645 {
646         return c->rename;
647 }
648
649 void
650 smbc_setFunctionRename(SMBCCTX *c, smbc_rename_fn fn)
651 {
652         c->rename = fn;
653 }
654
655 smbc_lseek_fn
656 smbc_getFunctionLseek(SMBCCTX *c)
657 {
658         return c->lseek;
659 }
660
661 void
662 smbc_setFunctionLseek(SMBCCTX *c, smbc_lseek_fn fn)
663 {
664         c->lseek = fn;
665 }
666
667 smbc_stat_fn
668 smbc_getFunctionStat(SMBCCTX *c)
669 {
670         return c->stat;
671 }
672
673 void
674 smbc_setFunctionStat(SMBCCTX *c, smbc_stat_fn fn)
675 {
676         c->stat = fn;
677 }
678
679 smbc_fstat_fn
680 smbc_getFunctionFstat(SMBCCTX *c)
681 {
682         return c->fstat;
683 }
684
685 void
686 smbc_setFunctionFstat(SMBCCTX *c, smbc_fstat_fn fn)
687 {
688         c->fstat = fn;
689 }
690
691 smbc_statvfs_fn
692 smbc_getFunctionStatVFS(SMBCCTX *c)
693 {
694         return c->internal->posix_emu.statvfs_fn;
695 }
696
697 void
698 smbc_setFunctionStatVFS(SMBCCTX *c, smbc_statvfs_fn fn)
699 {
700         c->internal->posix_emu.statvfs_fn = fn;
701 }
702
703 smbc_fstatvfs_fn
704 smbc_getFunctionFstatVFS(SMBCCTX *c)
705 {
706         return c->internal->posix_emu.fstatvfs_fn;
707 }
708
709 void
710 smbc_setFunctionFstatVFS(SMBCCTX *c, smbc_fstatvfs_fn fn)
711 {
712         c->internal->posix_emu.fstatvfs_fn = fn;
713 }
714
715 smbc_ftruncate_fn
716 smbc_getFunctionFtruncate(SMBCCTX *c)
717 {
718         return c->internal->posix_emu.ftruncate_fn;
719 }
720
721 void
722 smbc_setFunctionFtruncate(SMBCCTX *c, smbc_ftruncate_fn fn)
723 {
724         c->internal->posix_emu.ftruncate_fn = fn;
725 }
726
727 smbc_close_fn
728 smbc_getFunctionClose(SMBCCTX *c)
729 {
730         return c->close_fn;
731 }
732
733 void
734 smbc_setFunctionClose(SMBCCTX *c, smbc_close_fn fn)
735 {
736         c->close_fn = fn;
737 }
738
739
740 /**
741  * Callable functions for directories.
742  */
743
744 smbc_opendir_fn
745 smbc_getFunctionOpendir(SMBCCTX *c)
746 {
747         return c->opendir;
748 }
749
750 void
751 smbc_setFunctionOpendir(SMBCCTX *c, smbc_opendir_fn fn)
752 {
753         c->opendir = fn;
754 }
755
756 smbc_closedir_fn
757 smbc_getFunctionClosedir(SMBCCTX *c)
758 {
759         return c->closedir;
760 }
761
762 void
763 smbc_setFunctionClosedir(SMBCCTX *c, smbc_closedir_fn fn)
764 {
765         c->closedir = fn;
766 }
767
768 smbc_readdir_fn
769 smbc_getFunctionReaddir(SMBCCTX *c)
770 {
771         return c->readdir;
772 }
773
774 void
775 smbc_setFunctionReaddir(SMBCCTX *c, smbc_readdir_fn fn)
776 {
777         c->readdir = fn;
778 }
779
780 smbc_getdents_fn
781 smbc_getFunctionGetdents(SMBCCTX *c)
782 {
783         return c->getdents;
784 }
785
786 void
787 smbc_setFunctionGetdents(SMBCCTX *c, smbc_getdents_fn fn)
788 {
789         c->getdents = fn;
790 }
791
792 smbc_mkdir_fn
793 smbc_getFunctionMkdir(SMBCCTX *c)
794 {
795         return c->mkdir;
796 }
797
798 void
799 smbc_setFunctionMkdir(SMBCCTX *c, smbc_mkdir_fn fn)
800 {
801         c->mkdir = fn;
802 }
803
804 smbc_rmdir_fn
805 smbc_getFunctionRmdir(SMBCCTX *c)
806 {
807         return c->rmdir;
808 }
809
810 void
811 smbc_setFunctionRmdir(SMBCCTX *c, smbc_rmdir_fn fn)
812 {
813         c->rmdir = fn;
814 }
815
816 smbc_telldir_fn
817 smbc_getFunctionTelldir(SMBCCTX *c)
818 {
819         return c->telldir;
820 }
821
822 void
823 smbc_setFunctionTelldir(SMBCCTX *c, smbc_telldir_fn fn)
824 {
825         c->telldir = fn;
826 }
827
828 smbc_lseekdir_fn
829 smbc_getFunctionLseekdir(SMBCCTX *c)
830 {
831         return c->lseekdir;
832 }
833
834 void
835 smbc_setFunctionLseekdir(SMBCCTX *c, smbc_lseekdir_fn fn)
836 {
837         c->lseekdir = fn;
838 }
839
840 smbc_fstatdir_fn
841 smbc_getFunctionFstatdir(SMBCCTX *c)
842 {
843         return c->fstatdir;
844 }
845
846 void
847 smbc_setFunctionFstatdir(SMBCCTX *c, smbc_fstatdir_fn fn)
848 {
849         c->fstatdir = fn;
850 }
851
852
853 /**
854  * Callable functions applicable to both files and directories.
855  */
856
857 smbc_chmod_fn
858 smbc_getFunctionChmod(SMBCCTX *c)
859 {
860         return c->chmod;
861 }
862
863 void
864 smbc_setFunctionChmod(SMBCCTX *c, smbc_chmod_fn fn)
865 {
866         c->chmod = fn;
867 }
868
869 smbc_utimes_fn
870 smbc_getFunctionUtimes(SMBCCTX *c)
871 {
872         return c->utimes;
873 }
874
875 void
876 smbc_setFunctionUtimes(SMBCCTX *c, smbc_utimes_fn fn)
877 {
878         c->utimes = fn;
879 }
880
881 smbc_setxattr_fn
882 smbc_getFunctionSetxattr(SMBCCTX *c)
883 {
884         return c->setxattr;
885 }
886
887 void
888 smbc_setFunctionSetxattr(SMBCCTX *c, smbc_setxattr_fn fn)
889 {
890         c->setxattr = fn;
891 }
892
893 smbc_getxattr_fn
894 smbc_getFunctionGetxattr(SMBCCTX *c)
895 {
896         return c->getxattr;
897 }
898
899 void
900 smbc_setFunctionGetxattr(SMBCCTX *c, smbc_getxattr_fn fn)
901 {
902         c->getxattr = fn;
903 }
904
905 smbc_removexattr_fn
906 smbc_getFunctionRemovexattr(SMBCCTX *c)
907 {
908         return c->removexattr;
909 }
910
911 void
912 smbc_setFunctionRemovexattr(SMBCCTX *c, smbc_removexattr_fn fn)
913 {
914         c->removexattr = fn;
915 }
916
917 smbc_listxattr_fn
918 smbc_getFunctionListxattr(SMBCCTX *c)
919 {
920         return c->listxattr;
921 }
922
923 void
924 smbc_setFunctionListxattr(SMBCCTX *c, smbc_listxattr_fn fn)
925 {
926         c->listxattr = fn;
927 }
928
929
930 /**
931  * Callable functions related to printing
932  */
933
934 smbc_print_file_fn
935 smbc_getFunctionPrintFile(SMBCCTX *c)
936 {
937         return c->print_file;
938 }
939
940 void
941 smbc_setFunctionPrintFile(SMBCCTX *c, smbc_print_file_fn fn)
942 {
943         c->print_file = fn;
944 }
945
946 smbc_open_print_job_fn
947 smbc_getFunctionOpenPrintJob(SMBCCTX *c)
948 {
949         return c->open_print_job;
950 }
951
952 void
953 smbc_setFunctionOpenPrintJob(SMBCCTX *c,
954                              smbc_open_print_job_fn fn)
955 {
956         c->open_print_job = fn;
957 }
958
959 smbc_list_print_jobs_fn
960 smbc_getFunctionListPrintJobs(SMBCCTX *c)
961 {
962         return c->list_print_jobs;
963 }
964
965 void
966 smbc_setFunctionListPrintJobs(SMBCCTX *c,
967                               smbc_list_print_jobs_fn fn)
968 {
969         c->list_print_jobs = fn;
970 }
971
972 smbc_unlink_print_job_fn
973 smbc_getFunctionUnlinkPrintJob(SMBCCTX *c)
974 {
975         return c->unlink_print_job;
976 }
977
978 void
979 smbc_setFunctionUnlinkPrintJob(SMBCCTX *c,
980                                smbc_unlink_print_job_fn fn)
981 {
982         c->unlink_print_job = fn;
983 }
984