c107ab222030897fa415d82018d325be6472c898
[gd/samba/.git] / source / libsmb / libsmb_context.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 #include "libsmbclient.h"
27 #include "libsmb_internal.h"
28
29
30 /*
31  * Is the logging working / configfile read ? 
32  */
33 static int SMBC_initialized = 0;
34
35
36
37 /*
38  * Get a new empty handle to fill in with your own info
39  */
40 SMBCCTX *
41 smbc_new_context(void)
42 {
43         SMBCCTX *context;
44         
45         /*
46          * All newly added context fields should be placed in
47          * SMBC_internal_data, not directly in SMBCCTX.
48          */
49 #undef OLD
50 #define OLD(field)      context->field
51 #undef NEW
52 #define NEW(field)      context->internal->field
53         
54         context = SMB_MALLOC_P(SMBCCTX);
55         if (!context) {
56                 errno = ENOMEM;
57                 return NULL;
58         }
59         
60         ZERO_STRUCTP(context);
61         
62         context->internal = SMB_MALLOC_P(struct SMBC_internal_data);
63         if (!context->internal) {
64                 SAFE_FREE(context);
65                 errno = ENOMEM;
66                 return NULL;
67         }
68         
69         /* Initialize the context and establish reasonable defaults */
70         ZERO_STRUCTP(context->internal);
71         
72         OLD(config.debug)              = 0;
73         OLD(config.timeout)            = 20000; /* 20 seconds */
74         
75         NEW(full_time_names)           = False;
76         NEW(share_mode)                = SMBC_SHAREMODE_DENY_NONE;
77         NEW(smb_encryption_level)      = 0;
78         OLD(options.browse_max_lmb_count)      = 3;    /* # LMBs to query */
79         OLD(options.urlencode_readdir_entries) = False;
80         OLD(options.one_share_per_server)      = False;
81         
82         OLD(server.get_auth_data_fn)        = SMBC_get_auth_data;
83         OLD(server.check_server_fn)         = SMBC_check_server;
84         OLD(server.remove_unused_server_fn) = SMBC_remove_unused_server;
85         
86         OLD(cache.server_cache_data)        = NULL;
87         OLD(cache.add_cached_server_fn)     = SMBC_add_cached_server;
88         OLD(cache.get_cached_server_fn)     = SMBC_get_cached_server;
89         OLD(cache.remove_cached_server_fn)  = SMBC_remove_cached_server;
90         OLD(cache.purge_cached_servers_fn)  = SMBC_purge_cached_servers;
91         
92         OLD(posix_emu.open_fn)               = SMBC_open_ctx;
93         OLD(posix_emu.creat_fn)              = SMBC_creat_ctx;
94         OLD(posix_emu.read_fn)               = SMBC_read_ctx;
95         OLD(posix_emu.write_fn)              = SMBC_write_ctx;
96         OLD(posix_emu.close_fn)              = SMBC_close_ctx;
97         OLD(posix_emu.unlink_fn)             = SMBC_unlink_ctx;
98         OLD(posix_emu.rename_fn)             = SMBC_rename_ctx;
99         OLD(posix_emu.lseek_fn)              = SMBC_lseek_ctx;
100         NEW(posix_emu.ftruncate_fn)          = SMBC_ftruncate_ctx;
101         OLD(posix_emu.stat_fn)               = SMBC_stat_ctx;
102         OLD(posix_emu.fstat_fn)              = SMBC_fstat_ctx;
103         OLD(posix_emu.opendir_fn)            = SMBC_opendir_ctx;
104         OLD(posix_emu.closedir_fn)           = SMBC_closedir_ctx;
105         OLD(posix_emu.readdir_fn)            = SMBC_readdir_ctx;
106         OLD(posix_emu.getdents_fn)           = SMBC_getdents_ctx;
107         OLD(posix_emu.mkdir_fn)              = SMBC_mkdir_ctx;
108         OLD(posix_emu.rmdir_fn)              = SMBC_rmdir_ctx;
109         OLD(posix_emu.telldir_fn)            = SMBC_telldir_ctx;
110         OLD(posix_emu.lseekdir_fn)           = SMBC_lseekdir_ctx;
111         OLD(posix_emu.fstatdir_fn)           = SMBC_fstatdir_ctx;
112         OLD(posix_emu.chmod_fn)              = SMBC_chmod_ctx;
113         OLD(posix_emu.utimes_fn)             = SMBC_utimes_ctx;
114         OLD(posix_emu.setxattr_fn)           = SMBC_setxattr_ctx;
115         OLD(posix_emu.getxattr_fn)           = SMBC_getxattr_ctx;
116         OLD(posix_emu.removexattr_fn)        = SMBC_removexattr_ctx;
117         OLD(posix_emu.listxattr_fn)          = SMBC_listxattr_ctx;
118         
119         OLD(printing.open_print_job_fn)      = SMBC_open_print_job_ctx;
120         OLD(printing.print_file_fn)          = SMBC_print_file_ctx;
121         OLD(printing.list_print_jobs_fn)     = SMBC_list_print_jobs_ctx;
122         OLD(printing.unlink_print_job_fn)    = SMBC_unlink_print_job_ctx;
123         
124         return context;
125 #undef OLD
126 #undef NEW
127 }
128
129 /*
130  * Free a context
131  *
132  * Returns 0 on success. Otherwise returns 1, the SMBCCTX is _not_ freed
133  * and thus you'll be leaking memory if not handled properly.
134  *
135  */
136 int
137 smbc_free_context(SMBCCTX *context,
138                   int shutdown_ctx)
139 {
140         if (!context) {
141                 errno = EBADF;
142                 return 1;
143         }
144         
145         if (shutdown_ctx) {
146                 SMBCFILE * f;
147                 DEBUG(1,("Performing aggressive shutdown.\n"));
148                 
149                 f = context->internal->files;
150                 while (f) {
151                         (context->posix_emu.close_fn)(context, f);
152                         f = f->next;
153                 }
154                 context->internal->files = NULL;
155                 
156                 /* First try to remove the servers the nice way. */
157                 if (context->cache.purge_cached_servers_fn(context)) {
158                         SMBCSRV * s;
159                         SMBCSRV * next;
160                         DEBUG(1, ("Could not purge all servers, "
161                                   "Nice way shutdown failed.\n"));
162                         s = context->internal->servers;
163                         while (s) {
164                                 DEBUG(1, ("Forced shutdown: %p (fd=%d)\n",
165                                           s, s->cli->fd));
166                                 cli_shutdown(s->cli);
167                                 (context->cache.remove_cached_server_fn)(context,
168                                                                          s);
169                                 next = s->next;
170                                 DLIST_REMOVE(context->internal->servers, s);
171                                 SAFE_FREE(s);
172                                 s = next;
173                         }
174                         context->internal->servers = NULL;
175                 }
176         }
177         else {
178                 /* This is the polite way */
179                 if ((context->cache.purge_cached_servers_fn)(context)) {
180                         DEBUG(1, ("Could not purge all servers, "
181                                   "free_context failed.\n"));
182                         errno = EBUSY;
183                         return 1;
184                 }
185                 if (context->internal->servers) {
186                         DEBUG(1, ("Active servers in context, "
187                                   "free_context failed.\n"));
188                         errno = EBUSY;
189                         return 1;
190                 }
191                 if (context->internal->files) {
192                         DEBUG(1, ("Active files in context, "
193                                   "free_context failed.\n"));
194                         errno = EBUSY;
195                         return 1;
196                 }
197         }
198         
199         /* Things we have to clean up */
200         SAFE_FREE(context->config.workgroup);
201         SAFE_FREE(context->config.netbios_name);
202         SAFE_FREE(context->config.user);
203         
204         DEBUG(3, ("Context %p successfully freed\n", context));
205         SAFE_FREE(context);
206         return 0;
207 }
208
209
210 /**
211  * Deprecated interface.  Do not use.  Instead, use the various
212  * smbc_setOption*() functions or smbc_setFunctionAuthDataWithContext().
213  */
214 void
215 smbc_option_set(SMBCCTX *context,
216                 char *option_name,
217                 ... /* option_value */)
218 {
219         va_list ap;
220         union {
221                 int i;
222                 bool b;
223                 smbc_get_auth_data_with_context_fn auth_fn;
224                 void *v;
225                 const char *s;
226         } option_value;
227         
228         va_start(ap, option_name);
229         
230         if (strcmp(option_name, "debug_to_stderr") == 0) {
231                 option_value.b = (bool) va_arg(ap, int);
232                 smbc_setOptionDebugToStderr(context, option_value.b);
233                 
234         } else if (strcmp(option_name, "full_time_names") == 0) {
235                 option_value.b = (bool) va_arg(ap, int);
236                 smbc_setOptionFullTimeNames(context, option_value.b);
237                 
238         } else if (strcmp(option_name, "open_share_mode") == 0) {
239                 option_value.i = va_arg(ap, int);
240                 smbc_setOptionOpenShareMode(context, option_value.i);
241                 
242         } else if (strcmp(option_name, "auth_function") == 0) {
243                 option_value.auth_fn =
244                         va_arg(ap, smbc_get_auth_data_with_context_fn);
245                 smbc_setFunctionAuthDataWithContext(context, option_value.auth_fn);
246                 
247         } else if (strcmp(option_name, "user_data") == 0) {
248                 option_value.v = va_arg(ap, void *);
249                 smbc_setOptionUserData(context, option_value.v);
250                 
251         } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
252                 option_value.s = va_arg(ap, const char *);
253                 if (strcmp(option_value.s, "none") == 0) {
254                         smbc_setOptionSmbEncryptionLevel(context,
255                                                          SMBC_ENCRYPTLEVEL_NONE);
256                 } else if (strcmp(option_value.s, "request") == 0) {
257                         smbc_setOptionSmbEncryptionLevel(context,
258                                                          SMBC_ENCRYPTLEVEL_REQUEST);
259                 } else if (strcmp(option_value.s, "require") == 0) {
260                         smbc_setOptionSmbEncryptionLevel(context,
261                                                          SMBC_ENCRYPTLEVEL_REQUIRE);
262                 }
263                 
264         } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
265                 option_value.i = va_arg(ap, int);
266                 smbc_setOptionBrowseMaxLmbCount(context, option_value.i);
267                 
268         } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
269                 option_value.b = (bool) va_arg(ap, int);
270                 smbc_setOptionUrlEncodeReaddirEntries(context, option_value.b);
271                 
272         } else if (strcmp(option_name, "one_share_per_server") == 0) {
273                 option_value.b = (bool) va_arg(ap, int);
274                 smbc_setOptionOneSharePerServer(context, option_value.b);
275                 
276         } else if (strcmp(option_name, "use_kerberos") == 0) {
277                 option_value.b = (bool) va_arg(ap, int);
278                 smbc_setOptionUseKerberos(context, option_value.b);
279                 
280         } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
281                 option_value.b = (bool) va_arg(ap, int);
282                 smbc_setOptionFallbackAfterKerberos(context, option_value.b);
283                 
284         } else if (strcmp(option_name, "no_auto_anonymous_login") == 0) {
285                 option_value.b = (bool) va_arg(ap, int);
286                 smbc_setOptionNoAutoAnonymousLogin(context, option_value.b);
287         }
288         
289         va_end(ap);
290 }
291
292
293 /*
294  * Deprecated interface.  Do not use.  Instead, use the various
295  * smbc_getOption*() functions.
296  */
297 void *
298 smbc_option_get(SMBCCTX *context,
299                 char *option_name)
300 {
301         int             bits;
302         
303         if (strcmp(option_name, "debug_stderr") == 0) {
304 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
305                 return (void *) (intptr_t) smbc_getOptionDebugToStderr(context);
306 #else
307                 return (void *) smbc_getOptionDebugToStderr(context);
308 #endif
309                 
310         } else if (strcmp(option_name, "full_time_names") == 0) {
311 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
312                 return (void *) (intptr_t) smbc_getOptionFullTimeNames(context);
313 #else
314                 return (void *) smbc_getOptionFullTimeNames(context);
315 #endif
316                 
317         } else if (strcmp(option_name, "open_share_mode") == 0) {
318 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
319                 return (void *) (intptr_t) smbc_getOptionOpenShareMode(context);
320 #else
321                 return (void *) smbc_getOptionOpenShareMode(context);
322 #endif
323                 
324         } else if (strcmp(option_name, "auth_function") == 0) {
325                 return (void *) smbc_getFunctionAuthDataWithContext(context);
326                 
327         } else if (strcmp(option_name, "user_data") == 0) {
328                 return smbc_getOptionUserData(context);
329                 
330         } else if (strcmp(option_name, "smb_encrypt_level") == 0) {
331                 switch(smbc_getOptionSmbEncryptionLevel(context))
332                 {
333                 case 0:
334                         return (void *) "none";
335                 case 1:
336                         return (void *) "request";
337                 case 2:
338                         return (void *) "require";
339                 }
340                 
341         } else if (strcmp(option_name, "smb_encrypt_on") == 0) {
342                 SMBCSRV *s;
343                 unsigned int num_servers = 0;
344                 
345                 for (s = context->internal->servers; s; s = s->next) {
346                         num_servers++;
347                         if (s->cli->trans_enc_state == NULL) {
348                                 return (void *)false;
349                         }
350                 }
351 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
352                 return (void *) (intptr_t) (bool) (num_servers > 0);
353 #else
354                 return (void *) (bool) (num_servers > 0);
355 #endif
356                 
357         } else if (strcmp(option_name, "browse_max_lmb_count") == 0) {
358 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
359                 return (void *) (intptr_t) smbc_getOptionBrowseMaxLmbCount(context);
360 #else
361                 return (void *) smbc_getOptionBrowseMaxLmbCount(context);
362 #endif
363                 
364         } else if (strcmp(option_name, "urlencode_readdir_entries") == 0) {
365 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
366                 return (void *)(intptr_t) smbc_getOptionUrlEncodeReaddirEntries(context);
367 #else
368                 return (void *) (bool) smbc_getOptionUrlEncodeReaddirEntries(context);
369 #endif
370                 
371         } else if (strcmp(option_name, "one_share_per_server") == 0) {
372 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
373                 return (void *) (intptr_t) smbc_getOptionOneSharePerServer(context);
374 #else
375                 return (void *) (bool) smbc_getOptionOneSharePerServer(context);
376 #endif
377                 
378         } else if (strcmp(option_name, "use_kerberos") == 0) {
379                 bits = context->flags.bits;
380 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
381                 return (void *) (intptr_t) smbc_getOptionUseKerberos(context);
382 #else
383                 return (void *) (bool) smbc_getOptionUseKerberos(context);
384 #endif
385                 
386         } else if (strcmp(option_name, "fallback_after_kerberos") == 0) {
387 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
388                 return (void *)(intptr_t) smbc_getOptionFallbackAfterKerberos(context);
389 #else
390                 return (void *) (bool) smbc_getOptionFallbackAfterKerberos(context);
391 #endif
392                 
393         } else if (strcmp(option_name, "no_auto_anonymous_login") == 0) {
394 #if defined(__intptr_t_defined) || defined(HAVE_INTPTR_T)
395                 return (void *) (intptr_t) smbc_getOptionNoAutoAnonymousLogin(context);
396 #else
397                 return (void *) (bool) smbc_getOptionNoAutoAnonymousLogin(context);
398 #endif
399         }
400         
401         return NULL;
402 }
403
404
405 /*
406  * Initialize the library, etc.
407  *
408  * We accept a struct containing handle information.
409  * valid values for info->debug from 0 to 100,
410  * and insist that info->fn must be non-null.
411  */
412 SMBCCTX *
413 smbc_init_context(SMBCCTX *context)
414 {
415         int pid;
416         char *user = NULL;
417         char *home = NULL;
418         extern bool in_client;
419         
420         if (!context) {
421                 errno = EBADF;
422                 return NULL;
423         }
424         
425         /* Do not initialise the same client twice */
426         if (context->internal->initialized) {
427                 return NULL;
428         }
429         
430         if (!context->server.get_auth_data_fn ||
431             context->config.debug < 0 ||
432             context->config.debug > 100) {
433                 
434                 errno = EINVAL;
435                 return NULL;
436                 
437         }
438         
439         if (!SMBC_initialized) {
440                 /*
441                  * Do some library-wide intializations the first time we get
442                  * called
443                  */
444                 bool conf_loaded = False;
445                 TALLOC_CTX *frame = talloc_stackframe();
446                 
447                 /* Set this to what the user wants */
448                 DEBUGLEVEL = context->config.debug;
449                
450                 load_case_tables();
451                 
452                 setup_logging("libsmbclient", True);
453                 if (context->internal->debug_stderr) {
454                         dbf = x_stderr;
455                         x_setbuf(x_stderr, NULL);
456                 }
457                 
458                 /* Here we would open the smb.conf file if needed ... */
459                 
460                 in_client = True; /* FIXME, make a param */
461                 
462                 home = getenv("HOME");
463                 if (home) {
464                         char *conf = NULL;
465                         if (asprintf(&conf, "%s/.smb/smb.conf", home) > 0) {
466                                 if (lp_load(conf, True, False, False, True)) {
467                                         conf_loaded = True;
468                                 } else {
469                                         DEBUG(5, ("Could not load config file: %s\n",
470                                                   conf));
471                                 }
472                                 SAFE_FREE(conf);
473                         }
474                 }
475                 
476                 if (!conf_loaded) {
477                         /*
478                          * Well, if that failed, try the get_dyn_CONFIGFILE
479                          * Which points to the standard locn, and if that
480                          * fails, silently ignore it and use the internal
481                          * defaults ...
482                          */
483                         
484                         if (!lp_load(get_dyn_CONFIGFILE(), True, False, False, False)) {
485                                 DEBUG(5, ("Could not load config file: %s\n",
486                                           get_dyn_CONFIGFILE()));
487                         } else if (home) {
488                                 char *conf;
489                                 /*
490                                  * We loaded the global config file.  Now lets
491                                  * load user-specific modifications to the
492                                  * global config.
493                                  */
494                                 if (asprintf(&conf,
495                                              "%s/.smb/smb.conf.append",
496                                              home) > 0) {
497                                         if (!lp_load(conf, True, False, False, False)) {
498                                                 DEBUG(10,
499                                                       ("Could not append config file: "
500                                                        "%s\n",
501                                                        conf));
502                                         }
503                                         SAFE_FREE(conf);
504                                 }
505                         }
506                 }
507                 
508                 load_interfaces();  /* Load the list of interfaces ... */
509                 
510                 reopen_logs();  /* Get logging working ... */
511                 
512                 /*
513                  * Block SIGPIPE (from lib/util_sock.c: write())
514                  * It is not needed and should not stop execution
515                  */
516                 BlockSignals(True, SIGPIPE);
517                 
518                 /* Done with one-time initialisation */
519                 SMBC_initialized = 1;
520                 
521                 TALLOC_FREE(frame);
522         }
523         
524         if (!context->config.user) {
525                 /*
526                  * FIXME: Is this the best way to get the user info?
527                  */
528                 user = getenv("USER");
529                 /* walk around as "guest" if no username can be found */
530                 if (!user) context->config.user = SMB_STRDUP("guest");
531                 else context->config.user = SMB_STRDUP(user);
532         }
533         
534         if (!context->config.netbios_name) {
535                 /*
536                  * We try to get our netbios name from the config. If that
537                  * fails we fall back on constructing our netbios name from
538                  * our hostname etc
539                  */
540                 if (global_myname()) {
541                         context->config.netbios_name = SMB_STRDUP(global_myname());
542                 }
543                 else {
544                         /*
545                          * Hmmm, I want to get hostname as well, but I am too
546                          * lazy for the moment
547                          */
548                         pid = sys_getpid();
549                         context->config.netbios_name = (char *)SMB_MALLOC(17);
550                         if (!context->config.netbios_name) {
551                                 errno = ENOMEM;
552                                 return NULL;
553                         }
554                         slprintf(context->config.netbios_name, 16,
555                                  "smbc%s%d", context->config.user, pid);
556                 }
557         }
558         
559         DEBUG(1, ("Using netbios name %s.\n", context->config.netbios_name));
560         
561         if (!context->config.workgroup) {
562                 if (lp_workgroup()) {
563                         context->config.workgroup = SMB_STRDUP(lp_workgroup());
564                 }
565                 else {
566                         /* TODO: Think about a decent default workgroup */
567                         context->config.workgroup = SMB_STRDUP("samba");
568                 }
569         }
570         
571         DEBUG(1, ("Using workgroup %s.\n", context->config.workgroup));
572         
573         /* shortest timeout is 1 second */
574         if (context->config.timeout > 0 && context->config.timeout < 1000)
575                 context->config.timeout = 1000;
576         
577         /*
578          * FIXME: Should we check the function pointers here?
579          */
580         
581         context->internal->initialized = True;
582         
583         return context;
584 }
585
586
587 /* Return the verion of samba, and thus libsmbclient */
588 const char *
589 smbc_version(void)
590 {
591         return samba_version_string();
592 }
593
594
595 /** Get the netbios name used for making connections */
596 char *
597 smbc_getNetbiosName(SMBCCTX *c)
598 {
599         return c->config.netbios_name;
600 }
601
602 /** Set the netbios name used for making connections */
603 void
604 smbc_setNetbiosName(SMBCCTX *c, char * netbios_name)
605 {
606         c->config.netbios_name = netbios_name;
607 }
608
609 /** Get the workgroup used for making connections */
610 char *
611 smbc_getWorkgroup(SMBCCTX *c)
612 {
613         return c->config.workgroup;
614 }
615
616 /** Set the workgroup used for making connections */
617 void
618 smbc_setWorkgroup(SMBCCTX *c, char * workgroup)
619 {
620         c->config.workgroup = workgroup;
621 }
622
623 /** Get the username used for making connections */
624 char *
625 smbc_getUser(SMBCCTX *c)
626 {
627         return c->config.user;
628 }
629
630 /** Set the username used for making connections */
631 void
632 smbc_setUser(SMBCCTX *c, char * user)
633 {
634         c->config.user = user;
635 }
636
637 /** Get the debug level */
638 int
639 smbc_getDebug(SMBCCTX *c)
640 {
641         return c->config.debug;
642 }
643
644 /** Set the debug level */
645 void
646 smbc_setDebug(SMBCCTX *c, int debug)
647 {
648         c->config.debug = debug;
649 }
650
651 /**
652  * Get the timeout used for waiting on connections and response data
653  * (in milliseconds)
654  */
655 int
656 smbc_getTimeout(SMBCCTX *c)
657 {
658         return c->config.timeout;
659 }
660
661 /**
662  * Set the timeout used for waiting on connections and response data
663  * (in milliseconds)
664  */
665 void
666 smbc_setTimeout(SMBCCTX *c, int timeout)
667 {
668         c->config.timeout = timeout;
669 }
670
671 /** Get whether to log to standard error instead of standard output */
672 smbc_bool
673 smbc_getOptionDebugToStderr(SMBCCTX *c)
674 {
675         return c->internal->debug_stderr;
676 }
677
678 /** Set whether to log to standard error instead of standard output */
679 void
680 smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b)
681 {
682         c->internal->debug_stderr = b;
683 }
684
685 /**
686  * Get whether to use new-style time attribute names, e.g. WRITE_TIME rather
687  * than the old-style names such as M_TIME.  This allows also setting/getting
688  * CREATE_TIME which was previously unimplemented.  (Note that the old C_TIME
689  * was supposed to be CHANGE_TIME but was confused and sometimes referred to
690  * CREATE_TIME.)
691  */
692 smbc_bool
693 smbc_getOptionFullTimeNames(SMBCCTX *c)
694 {
695         return c->internal->full_time_names;
696 }
697
698 /**
699  * Set whether to use new-style time attribute names, e.g. WRITE_TIME rather
700  * than the old-style names such as M_TIME.  This allows also setting/getting
701  * CREATE_TIME which was previously unimplemented.  (Note that the old C_TIME
702  * was supposed to be CHANGE_TIME but was confused and sometimes referred to
703  * CREATE_TIME.)
704  */
705 void
706 smbc_setOptionFullTimeNames(SMBCCTX *c, smbc_bool b)
707 {
708         c->internal->full_time_names = b;
709 }
710
711 /**
712  * Get the share mode to use for files opened with SMBC_open_ctx().  The
713  * default is SMBC_SHAREMODE_DENY_NONE.
714  */
715 smbc_share_mode
716 smbc_getOptionOpenShareMode(SMBCCTX *c)
717 {
718         return c->internal->share_mode;
719 }
720
721 /**
722  * Set the share mode to use for files opened with SMBC_open_ctx().  The
723  * default is SMBC_SHAREMODE_DENY_NONE.
724  */
725 void
726 smbc_setOptionOpenShareMode(SMBCCTX *c, smbc_share_mode share_mode)
727 {
728         c->internal->share_mode = share_mode;
729 }
730
731 /** Retrieve a previously set user data handle */
732 void *
733 smbc_getOptionUserData(SMBCCTX *c)
734 {
735         return c->internal->user_data;
736 }
737
738 /** Save a user data handle */
739 void
740 smbc_setOptionUserData(SMBCCTX *c, void *user_data)
741 {
742         c->internal->user_data = user_data;
743 }
744
745 /** Get the encoded value for encryption level. */
746 smbc_smb_encrypt_level
747 smbc_getOptionSmbEncryptionLevel(SMBCCTX *c)
748 {
749         return c->internal->smb_encryption_level;
750 }
751
752 /** Set the encoded value for encryption level. */
753 void
754 smbc_setOptionSmbEncryptionLevel(SMBCCTX *c, smbc_smb_encrypt_level level)
755 {
756         c->internal->smb_encryption_level = level;
757 }
758
759 /**
760  * Get from how many local master browsers should the list of workgroups be
761  * retrieved.  It can take up to 12 minutes or longer after a server becomes a
762  * local master browser, for it to have the entire browse list (the list of
763  * workgroups/domains) from an entire network.  Since a client never knows
764  * which local master browser will be found first, the one which is found
765  * first and used to retrieve a browse list may have an incomplete or empty
766  * browse list.  By requesting the browse list from multiple local master
767  * browsers, a more complete list can be generated.  For small networks (few
768  * workgroups), it is recommended that this value be set to 0, causing the
769  * browse lists from all found local master browsers to be retrieved and
770  * merged.  For networks with many workgroups, a suitable value for this
771  * variable is probably somewhere around 3. (Default: 3).
772  */
773 int
774 smbc_getOptionBrowseMaxLmbCount(SMBCCTX *c)
775 {
776         return c->options.browse_max_lmb_count;
777 }
778
779 /**
780  * Set from how many local master browsers should the list of workgroups be
781  * retrieved.  It can take up to 12 minutes or longer after a server becomes a
782  * local master browser, for it to have the entire browse list (the list of
783  * workgroups/domains) from an entire network.  Since a client never knows
784  * which local master browser will be found first, the one which is found
785  * first and used to retrieve a browse list may have an incomplete or empty
786  * browse list.  By requesting the browse list from multiple local master
787  * browsers, a more complete list can be generated.  For small networks (few
788  * workgroups), it is recommended that this value be set to 0, causing the
789  * browse lists from all found local master browsers to be retrieved and
790  * merged.  For networks with many workgroups, a suitable value for this
791  * variable is probably somewhere around 3. (Default: 3).
792  */
793 void
794 smbc_setOptionBrowseMaxLmbCount(SMBCCTX *c, int count)
795 {
796         c->options.browse_max_lmb_count = count;
797 }
798
799 /**
800  * Get whether to url-encode readdir entries.
801  *
802  * There is a difference in the desired return strings from
803  * smbc_readdir() depending upon whether the filenames are to
804  * be displayed to the user, or whether they are to be
805  * appended to the path name passed to smbc_opendir() to call
806  * a further smbc_ function (e.g. open the file with
807  * smbc_open()).  In the former case, the filename should be
808  * in "human readable" form.  In the latter case, the smbc_
809  * functions expect a URL which must be url-encoded.  Those
810  * functions decode the URL.  If, for example, smbc_readdir()
811  * returned a file name of "abc%20def.txt", passing a path
812  * with this file name attached to smbc_open() would cause
813  * smbc_open to attempt to open the file "abc def.txt" since
814  * the %20 is decoded into a space.
815  *
816  * Set this option to True if the names returned by
817  * smbc_readdir() should be url-encoded such that they can be
818  * passed back to another smbc_ call.  Set it to False if the
819  * names returned by smbc_readdir() are to be presented to the
820  * user.
821  *
822  * For backwards compatibility, this option defaults to False.
823  */
824 smbc_bool
825 smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX *c)
826 {
827         return c->options.urlencode_readdir_entries;
828 }
829
830 /**
831  * Set whether to url-encode readdir entries.
832  *
833  * There is a difference in the desired return strings from
834  * smbc_readdir() depending upon whether the filenames are to
835  * be displayed to the user, or whether they are to be
836  * appended to the path name passed to smbc_opendir() to call
837  * a further smbc_ function (e.g. open the file with
838  * smbc_open()).  In the former case, the filename should be
839  * in "human readable" form.  In the latter case, the smbc_
840  * functions expect a URL which must be url-encoded.  Those
841  * functions decode the URL.  If, for example, smbc_readdir()
842  * returned a file name of "abc%20def.txt", passing a path
843  * with this file name attached to smbc_open() would cause
844  * smbc_open to attempt to open the file "abc def.txt" since
845  * the %20 is decoded into a space.
846  *
847  * Set this option to True if the names returned by
848  * smbc_readdir() should be url-encoded such that they can be
849  * passed back to another smbc_ call.  Set it to False if the
850  * names returned by smbc_readdir() are to be presented to the
851  * user.
852  *
853  * For backwards compatibility, this option defaults to False.
854  */
855 void
856 smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX *c, smbc_bool b)
857 {
858         c->options.urlencode_readdir_entries = b;
859 }
860
861 /**
862  * Get whether to use the same connection for all shares on a server.
863  *
864  * Some Windows versions appear to have a limit to the number
865  * of concurrent SESSIONs and/or TREE CONNECTions.  In
866  * one-shot programs (i.e. the program runs and then quickly
867  * ends, thereby shutting down all connections), it is
868  * probably reasonable to establish a new connection for each
869  * share.  In long-running applications, the limitation can be
870  * avoided by using only a single connection to each server,
871  * and issuing a new TREE CONNECT when the share is accessed.
872  */
873 smbc_bool
874 smbc_getOptionOneSharePerServer(SMBCCTX *c)
875 {
876         return c->options.one_share_per_server;
877 }
878
879 /**
880  * Set whether to use the same connection for all shares on a server.
881  *
882  * Some Windows versions appear to have a limit to the number
883  * of concurrent SESSIONs and/or TREE CONNECTions.  In
884  * one-shot programs (i.e. the program runs and then quickly
885  * ends, thereby shutting down all connections), it is
886  * probably reasonable to establish a new connection for each
887  * share.  In long-running applications, the limitation can be
888  * avoided by using only a single connection to each server,
889  * and issuing a new TREE CONNECT when the share is accessed.
890  */
891 void
892 smbc_setOptionOneSharePerServer(SMBCCTX *c, smbc_bool b)
893 {
894         c->options.one_share_per_server = b;
895 }
896
897 /** Get whether to enable use of kerberos */
898 smbc_bool
899 smbc_getOptionUseKerberos(SMBCCTX *c)
900 {
901         return c->flags.bits & SMB_CTX_FLAG_USE_KERBEROS ? True : False;
902 }
903
904 /** Set whether to enable use of kerberos */
905 void
906 smbc_setOptionUseKerberos(SMBCCTX *c, smbc_bool b)
907 {
908         if (b) {
909                 c->flags.bits |= SMB_CTX_FLAG_USE_KERBEROS;
910         } else {
911                 c->flags.bits &= ~SMB_CTX_FLAG_USE_KERBEROS;
912         }
913 }
914
915 /** Get whether to fallback after kerberos */
916 smbc_bool
917 smbc_getOptionFallbackAfterKerberos(SMBCCTX *c)
918 {
919         return c->flags.bits & SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS ? True : False;
920 }
921
922 /** Set whether to fallback after kerberos */
923 void
924 smbc_setOptionFallbackAfterKerberos(SMBCCTX *c, smbc_bool b)
925 {
926         if (b) {
927                 c->flags.bits |= SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
928         } else {
929                 c->flags.bits &= ~SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
930         }
931 }
932
933 /** Get whether to automatically select anonymous login */
934 smbc_bool
935 smbc_getOptionNoAutoAnonymousLogin(SMBCCTX *c)
936 {
937         return c->flags.bits & SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON ? True : False;
938 }
939
940 /** Set whether to automatically select anonymous login */
941 void
942 smbc_setOptionNoAutoAnonymousLogin(SMBCCTX *c, smbc_bool b)
943 {
944         if (b) {
945                 c->flags.bits |= SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
946         } else {
947                 c->flags.bits &= ~SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
948         }
949 }
950
951 /** Get the function for obtaining authentication data */
952 smbc_get_auth_data_fn
953 smbc_getFunctionAuthData(SMBCCTX *c)
954 {
955         return c->server.get_auth_data_fn;
956 }
957
958 /** Set the function for obtaining authentication data */
959 void
960 smbc_setFunctionAuthData(SMBCCTX *c, smbc_get_auth_data_fn fn)
961 {
962         c->internal->auth_fn_with_context = NULL;
963         c->server.get_auth_data_fn = fn;
964 }
965
966 /** Get the new-style authentication function which includes the context. */
967 smbc_get_auth_data_with_context_fn
968 smbc_getFunctionAuthDataWithContext(SMBCCTX *c)
969 {
970         return c->internal->auth_fn_with_context;
971 }
972
973 /** Set the new-style authentication function which includes the context. */
974 void
975 smbc_setFunctionAuthDataWithContext(SMBCCTX *c,
976                                     smbc_get_auth_data_with_context_fn fn)
977 {
978         c->server.get_auth_data_fn = NULL;
979         c->internal->auth_fn_with_context = fn;
980 }
981
982 /** Get the function for checking if a server is still good */
983 smbc_check_server_fn
984 smbc_getFunctionCheckServer(SMBCCTX *c)
985 {
986         return c->server.check_server_fn;
987 }
988
989 /** Set the function for checking if a server is still good */
990 void
991 smbc_setFunctionCheckServer(SMBCCTX *c, smbc_check_server_fn fn)
992 {
993         c->server.check_server_fn = fn;
994 }
995
996 /** Get the function for removing a server if unused */
997 smbc_remove_unused_server_fn
998 smbc_getFunctionRemoveUnusedServer(SMBCCTX *c)
999 {
1000         return c->server.remove_unused_server_fn;
1001 }
1002
1003 /** Set the function for removing a server if unused */
1004 void
1005 smbc_setFunctionRemoveUnusedServer(SMBCCTX *c,
1006                                    smbc_remove_unused_server_fn fn)
1007 {
1008         c->server.remove_unused_server_fn = fn;
1009 }
1010
1011 /** Get the function to store private data of the server cache */
1012 struct
1013 smbc_server_cache * smbc_getServerCacheData(SMBCCTX *c)
1014 {
1015         return c->cache.server_cache_data;
1016 }
1017
1018 /** Set the function to store private data of the server cache */
1019 void
1020 smbc_setServerCacheData(SMBCCTX *c, struct smbc_server_cache * cache)
1021 {
1022         c->cache.server_cache_data = cache;
1023 }
1024
1025
1026 /** Get the function for adding a cached server */
1027 smbc_add_cached_srv_fn
1028 smbc_getFunctionAddCachedServer(SMBCCTX *c)
1029 {
1030         return c->cache.add_cached_server_fn;
1031 }
1032
1033 /** Set the function for adding a cached server */
1034 void
1035 smbc_setFunctionAddCachedServer(SMBCCTX *c, smbc_add_cached_srv_fn fn)
1036 {
1037         c->cache.add_cached_server_fn = fn;
1038 }
1039
1040 /** Get the function for server cache lookup */
1041 smbc_get_cached_srv_fn
1042 smbc_getFunctionGetCachedServer(SMBCCTX *c)
1043 {
1044         return c->cache.get_cached_server_fn;
1045 }
1046
1047 /** Set the function for server cache lookup */
1048 void
1049 smbc_setFunctionGetCachedServer(SMBCCTX *c, smbc_get_cached_srv_fn fn)
1050 {
1051         c->cache.get_cached_server_fn = fn;
1052 }
1053
1054 /** Get the function for server cache removal */
1055 smbc_remove_cached_srv_fn
1056 smbc_getFunctionRemoveCachedServer(SMBCCTX *c)
1057 {
1058         return c->cache.remove_cached_server_fn;
1059 }
1060
1061 /** Set the function for server cache removal */
1062 void
1063 smbc_setFunctionRemoveCachedServer(SMBCCTX *c,
1064                                    smbc_remove_cached_srv_fn fn)
1065 {
1066         c->cache.remove_cached_server_fn = fn;
1067 }
1068
1069 /**
1070  * Get the function for server cache purging.  This function tries to
1071  * remove all cached servers (e.g. on disconnect)
1072  */
1073 smbc_purge_cached_srv_fn
1074 smbc_getFunctionPurgeCachedServers(SMBCCTX *c)
1075 {
1076         return c->cache.purge_cached_servers_fn;
1077 }
1078
1079 /**
1080  * Set the function for server cache purging.  This function tries to
1081  * remove all cached servers (e.g. on disconnect)
1082  */
1083 void
1084 smbc_setFunctionPurgeCachedServers(SMBCCTX *c, smbc_purge_cached_srv_fn fn)
1085 {
1086         c->cache.purge_cached_servers_fn = fn;
1087 }
1088
1089 /**
1090  * Callable functions for files.
1091  */
1092
1093 smbc_open_fn
1094 smbc_getFunctionOpen(SMBCCTX *c)
1095 {
1096         return c->posix_emu.open_fn;
1097 }
1098
1099 void
1100 smbc_setFunctionOpen(SMBCCTX *c, smbc_open_fn fn)
1101 {
1102         c->posix_emu.open_fn = fn;
1103 }
1104
1105 smbc_creat_fn
1106 smbc_getFunctionCreat(SMBCCTX *c)
1107 {
1108         return c->posix_emu.creat_fn;
1109 }
1110
1111 void
1112 smbc_setFunctionCreat(SMBCCTX *c, smbc_creat_fn fn)
1113 {
1114         c->posix_emu.creat_fn = fn;
1115 }
1116
1117 smbc_read_fn
1118 smbc_getFunctionRead(SMBCCTX *c)
1119 {
1120         return c->posix_emu.read_fn;
1121 }
1122
1123 void
1124 smbc_setFunctionRead(SMBCCTX *c, smbc_read_fn fn)
1125 {
1126         c->posix_emu.read_fn = fn;
1127 }
1128
1129 smbc_write_fn
1130 smbc_getFunctionWrite(SMBCCTX *c)
1131 {
1132         return c->posix_emu.write_fn;
1133 }
1134
1135 void
1136 smbc_setFunctionWrite(SMBCCTX *c, smbc_write_fn fn)
1137 {
1138         c->posix_emu.write_fn = fn;
1139 }
1140
1141 smbc_unlink_fn
1142 smbc_getFunctionUnlink(SMBCCTX *c)
1143 {
1144         return c->posix_emu.unlink_fn;
1145 }
1146
1147 void
1148 smbc_setFunctionUnlink(SMBCCTX *c, smbc_unlink_fn fn)
1149 {
1150         c->posix_emu.unlink_fn = fn;
1151 }
1152
1153 smbc_rename_fn
1154 smbc_getFunctionRename(SMBCCTX *c)
1155 {
1156         return c->posix_emu.rename_fn;
1157 }
1158
1159 void
1160 smbc_setFunctionRename(SMBCCTX *c, smbc_rename_fn fn)
1161 {
1162         c->posix_emu.rename_fn = fn;
1163 }
1164
1165 smbc_lseek_fn
1166 smbc_getFunctionLseek(SMBCCTX *c)
1167 {
1168         return c->posix_emu.lseek_fn;
1169 }
1170
1171 void
1172 smbc_setFunctionLseek(SMBCCTX *c, smbc_lseek_fn fn)
1173 {
1174         c->posix_emu.lseek_fn = fn;
1175 }
1176
1177 smbc_stat_fn
1178 smbc_getFunctionStat(SMBCCTX *c)
1179 {
1180         return c->posix_emu.stat_fn;
1181 }
1182
1183 void
1184 smbc_setFunctionStat(SMBCCTX *c, smbc_stat_fn fn)
1185 {
1186         c->posix_emu.stat_fn = fn;
1187 }
1188
1189 smbc_fstat_fn
1190 smbc_getFunctionFstat(SMBCCTX *c)
1191 {
1192         return c->posix_emu.fstat_fn;
1193 }
1194
1195 void
1196 smbc_setFunctionFstat(SMBCCTX *c, smbc_fstat_fn fn)
1197 {
1198         c->posix_emu.fstat_fn = fn;
1199 }
1200
1201 smbc_ftruncate_fn
1202 smbc_getFunctionFtruncate(SMBCCTX *c)
1203 {
1204         return c->internal->posix_emu.ftruncate_fn;
1205 }
1206
1207 void
1208 smbc_setFunctionFtruncate(SMBCCTX *c, smbc_ftruncate_fn fn)
1209 {
1210         c->internal->posix_emu.ftruncate_fn = fn;
1211 }
1212
1213 smbc_close_fn
1214 smbc_getFunctionClose(SMBCCTX *c)
1215 {
1216         return c->posix_emu.close_fn;
1217 }
1218
1219 void
1220 smbc_setFunctionClose(SMBCCTX *c, smbc_close_fn fn)
1221 {
1222         c->posix_emu.close_fn = fn;
1223 }
1224
1225
1226 /**
1227  * Callable functions for directories.
1228  */
1229
1230 smbc_opendir_fn
1231 smbc_getFunctionOpendir(SMBCCTX *c)
1232 {
1233         return c->posix_emu.opendir_fn;
1234 }
1235
1236 void
1237 smbc_setFunctionOpendir(SMBCCTX *c, smbc_opendir_fn fn)
1238 {
1239         c->posix_emu.opendir_fn = fn;
1240 }
1241
1242 smbc_closedir_fn
1243 smbc_getFunctionClosedir(SMBCCTX *c)
1244 {
1245         return c->posix_emu.closedir_fn;
1246 }
1247
1248 void
1249 smbc_setFunctionClosedir(SMBCCTX *c, smbc_closedir_fn fn)
1250 {
1251         c->posix_emu.closedir_fn = fn;
1252 }
1253
1254 smbc_readdir_fn
1255 smbc_getFunctionReaddir(SMBCCTX *c)
1256 {
1257         return c->posix_emu.readdir_fn;
1258 }
1259
1260 void
1261 smbc_setFunctionReaddir(SMBCCTX *c, smbc_readdir_fn fn)
1262 {
1263         c->posix_emu.readdir_fn = fn;
1264 }
1265
1266 smbc_getdents_fn
1267 smbc_getFunctionGetdents(SMBCCTX *c)
1268 {
1269         return c->posix_emu.getdents_fn;
1270 }
1271
1272 void
1273 smbc_setFunctionGetdents(SMBCCTX *c, smbc_getdents_fn fn)
1274 {
1275         c->posix_emu.getdents_fn = fn;
1276 }
1277
1278 smbc_mkdir_fn
1279 smbc_getFunctionMkdir(SMBCCTX *c)
1280 {
1281         return c->posix_emu.mkdir_fn;
1282 }
1283
1284 void
1285 smbc_setFunctionMkdir(SMBCCTX *c, smbc_mkdir_fn fn)
1286 {
1287         c->posix_emu.mkdir_fn = fn;
1288 }
1289
1290 smbc_rmdir_fn
1291 smbc_getFunctionRmdir(SMBCCTX *c)
1292 {
1293         return c->posix_emu.rmdir_fn;
1294 }
1295
1296 void
1297 smbc_setFunctionRmdir(SMBCCTX *c, smbc_rmdir_fn fn)
1298 {
1299         c->posix_emu.rmdir_fn = fn;
1300 }
1301
1302 smbc_telldir_fn
1303 smbc_getFunctionTelldir(SMBCCTX *c)
1304 {
1305         return c->posix_emu.telldir_fn;
1306 }
1307
1308 void
1309 smbc_setFunctionTelldir(SMBCCTX *c, smbc_telldir_fn fn)
1310 {
1311         c->posix_emu.telldir_fn = fn;
1312 }
1313
1314 smbc_lseekdir_fn
1315 smbc_getFunctionLseekdir(SMBCCTX *c)
1316 {
1317         return c->posix_emu.lseekdir_fn;
1318 }
1319
1320 void
1321 smbc_setFunctionLseekdir(SMBCCTX *c, smbc_lseekdir_fn fn)
1322 {
1323         c->posix_emu.lseekdir_fn = fn;
1324 }
1325
1326 smbc_fstatdir_fn
1327 smbc_getFunctionFstatdir(SMBCCTX *c)
1328 {
1329         return c->posix_emu.fstatdir_fn;
1330 }
1331
1332 void
1333 smbc_setFunctionFstatdir(SMBCCTX *c, smbc_fstatdir_fn fn)
1334 {
1335         c->posix_emu.fstatdir_fn = fn;
1336 }
1337
1338
1339 /**
1340  * Callable functions applicable to both files and directories.
1341  */
1342
1343 smbc_chmod_fn
1344 smbc_getFunctionChmod(SMBCCTX *c)
1345 {
1346         return c->posix_emu.chmod_fn;
1347 }
1348
1349 void
1350 smbc_setFunctionChmod(SMBCCTX *c, smbc_chmod_fn fn)
1351 {
1352         c->posix_emu.chmod_fn = fn;
1353 }
1354
1355 smbc_utimes_fn
1356 smbc_getFunctionUtimes(SMBCCTX *c)
1357 {
1358         return c->posix_emu.utimes_fn;
1359 }
1360
1361 void
1362 smbc_setFunctionUtimes(SMBCCTX *c, smbc_utimes_fn fn)
1363 {
1364         c->posix_emu.utimes_fn = fn;
1365 }
1366
1367 smbc_setxattr_fn
1368 smbc_getFunctionSetxattr(SMBCCTX *c)
1369 {
1370         return c->posix_emu.setxattr_fn;
1371 }
1372
1373 void
1374 smbc_setFunctionSetxattr(SMBCCTX *c, smbc_setxattr_fn fn)
1375 {
1376         c->posix_emu.setxattr_fn = fn;
1377 }
1378
1379 smbc_getxattr_fn
1380 smbc_getFunctionGetxattr(SMBCCTX *c)
1381 {
1382         return c->posix_emu.getxattr_fn;
1383 }
1384
1385 void
1386 smbc_setFunctionGetxattr(SMBCCTX *c, smbc_getxattr_fn fn)
1387 {
1388         c->posix_emu.getxattr_fn = fn;
1389 }
1390
1391 smbc_removexattr_fn
1392 smbc_getFunctionRemovexattr(SMBCCTX *c)
1393 {
1394         return c->posix_emu.removexattr_fn;
1395 }
1396
1397 void
1398 smbc_setFunctionRemovexattr(SMBCCTX *c, smbc_removexattr_fn fn)
1399 {
1400         c->posix_emu.removexattr_fn = fn;
1401 }
1402
1403 smbc_listxattr_fn
1404 smbc_getFunctionListxattr(SMBCCTX *c)
1405 {
1406         return c->posix_emu.listxattr_fn;
1407 }
1408
1409 void
1410 smbc_setFunctionListxattr(SMBCCTX *c, smbc_listxattr_fn fn)
1411 {
1412         c->posix_emu.listxattr_fn = fn;
1413 }
1414
1415
1416 /**
1417  * Callable functions related to printing
1418  */
1419
1420 smbc_print_file_fn
1421 smbc_getFunctionPrintFile(SMBCCTX *c)
1422 {
1423         return c->printing.print_file_fn;
1424 }
1425
1426 void
1427 smbc_setFunctionPrintFile(SMBCCTX *c, smbc_print_file_fn fn)
1428 {
1429         c->printing.print_file_fn = fn;
1430 }
1431
1432 smbc_open_print_job_fn
1433 smbc_getFunctionOpenPrintJob(SMBCCTX *c)
1434 {
1435         return c->printing.open_print_job_fn;
1436 }
1437
1438 void
1439 smbc_setFunctionOpenPrintJob(SMBCCTX *c,
1440                              smbc_open_print_job_fn fn)
1441 {
1442         c->printing.open_print_job_fn = fn;
1443 }
1444
1445 smbc_list_print_jobs_fn
1446 smbc_getFunctionListPrintJobs(SMBCCTX *c)
1447 {
1448         return c->printing.list_print_jobs_fn;
1449 }
1450
1451 void
1452 smbc_setFunctionListPrintJobs(SMBCCTX *c,
1453                               smbc_list_print_jobs_fn fn)
1454 {
1455         c->printing.list_print_jobs_fn = fn;
1456 }
1457
1458 smbc_unlink_print_job_fn
1459 smbc_getFunctionUnlinkPrintJob(SMBCCTX *c)
1460 {
1461         return c->printing.unlink_print_job_fn;
1462 }
1463
1464 void
1465 smbc_setFunctionUnlinkPrintJob(SMBCCTX *c,
1466                                smbc_unlink_print_job_fn fn)
1467 {
1468         c->printing.unlink_print_job_fn = fn;
1469 }
1470