source: branches/samba-3.2.x/source/libsmb/libsmb_setget.c

Last change on this file was 232, checked in by Herwig Bauernfeind, 16 years ago

Update 3.2 branch to 3.2.8

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