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 const char *
smbc_getNetbiosName(SMBCCTX * c)33 smbc_getNetbiosName(SMBCCTX *c)
34 {
35 return c->netbios_name;
36 }
37
38 /** Set the netbios name used for making connections */
39 void
smbc_setNetbiosName(SMBCCTX * c,const char * netbios_name)40 smbc_setNetbiosName(SMBCCTX *c, const 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 const char *
smbc_getWorkgroup(SMBCCTX * c)50 smbc_getWorkgroup(SMBCCTX *c)
51 {
52 return c->workgroup;
53 }
54
55 /** Set the workgroup used for making connections */
56 void
smbc_setWorkgroup(SMBCCTX * c,const char * workgroup)57 smbc_setWorkgroup(SMBCCTX *c, const 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 const char *
smbc_getUser(SMBCCTX * c)67 smbc_getUser(SMBCCTX *c)
68 {
69 return c->user;
70 }
71
72 /** Set the username used for making connections */
73 void
smbc_setUser(SMBCCTX * c,const char * user)74 smbc_setUser(SMBCCTX *c, const 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
smbc_getDebug(SMBCCTX * c)84 smbc_getDebug(SMBCCTX *c)
85 {
86 return c->debug;
87 }
88
89 /** Set the debug level */
90 void
smbc_setDebug(SMBCCTX * c,int debug)91 smbc_setDebug(SMBCCTX *c, int debug)
92 {
93 char buf[32];
94 TALLOC_CTX *frame = talloc_stackframe();
95 snprintf(buf, sizeof(buf), "%d", debug);
96 c->debug = debug;
97 lp_set_cmdline("log level", buf);
98 TALLOC_FREE(frame);
99 }
100
101 /** set callback function which will be called for logging */
102 void
smbc_setLogCallback(SMBCCTX * c,void * private_ptr,smbc_debug_callback_fn fn)103 smbc_setLogCallback(SMBCCTX *c, void *private_ptr,
104 smbc_debug_callback_fn fn)
105 {
106 debug_set_callback(private_ptr, fn);
107 }
108
109 /** set configuration file */
smbc_setConfiguration(SMBCCTX * c,const char * file)110 int smbc_setConfiguration(SMBCCTX *c, const char *file)
111 {
112 bool ok;
113
114 ok = lp_load_client_no_reinit(file);
115 if (!ok) {
116 DBG_WARNING("Could not load config file: %s\n", file);
117 errno = ENOENT;
118 return -1;
119 }
120
121 DBG_NOTICE("Configuration loaded successfully: %s\n", file);
122 return 0;
123 }
124 /**
125 * Get the timeout used for waiting on connections and response data
126 * (in milliseconds)
127 */
128 int
smbc_getTimeout(SMBCCTX * c)129 smbc_getTimeout(SMBCCTX *c)
130 {
131 return c->timeout;
132 }
133
134 /**
135 * Set the timeout used for waiting on connections and response data
136 * (in milliseconds)
137 */
138 void
smbc_setTimeout(SMBCCTX * c,int timeout)139 smbc_setTimeout(SMBCCTX *c, int timeout)
140 {
141 c->timeout = timeout;
142 }
143
144 /**
145 * Get the TCP port used to connect.
146 */
147 uint16_t
smbc_getPort(SMBCCTX * c)148 smbc_getPort(SMBCCTX *c)
149 {
150 return c->internal->port;
151 }
152
153 /**
154 * Set the TCP port used to connect.
155 */
156 void
smbc_setPort(SMBCCTX * c,uint16_t port)157 smbc_setPort(SMBCCTX *c, uint16_t port)
158 {
159 c->internal->port = port;
160 }
161
162
163 /** Get whether to log to standard error instead of standard output */
164 smbc_bool
smbc_getOptionDebugToStderr(SMBCCTX * c)165 smbc_getOptionDebugToStderr(SMBCCTX *c)
166 {
167 smbc_bool ret;
168 TALLOC_CTX *frame = talloc_stackframe();
169
170 /* Because this is a global concept, it is better to check
171 * what is really set, rather than what we wanted set
172 * (particularly as you cannot go back to stdout). */
173 ret = debug_get_output_is_stderr();
174 TALLOC_FREE(frame);
175 return ret;
176 }
177
178 /** Set whether to log to standard error instead of standard output.
179 * This option is 'sticky' - once set to true, it cannot be set to
180 * false again, as it is global to the process, as once we have been
181 * told that it is not safe to safe to write to stdout, we shouldn't
182 * go back as we don't know it was this context that set it that way.
183 */
184 void
smbc_setOptionDebugToStderr(SMBCCTX * c,smbc_bool b)185 smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b)
186 {
187 TALLOC_CTX *frame = talloc_stackframe();
188 if (b) {
189 /*
190 * We do not have a unique per-thread debug state? For
191 * now, we'll just leave it up to the user. If any one
192 * context spefies debug to stderr then all will be (and
193 * will stay that way, as it is unsafe to flip back if
194 * stdout is in use for other things)
195 */
196 setup_logging("libsmbclient", DEBUG_STDERR);
197 }
198 TALLOC_FREE(frame);
199 }
200
201 /**
202 * Get whether to use new-style time attribute names, e.g. WRITE_TIME rather
203 * than the old-style names such as M_TIME. This allows also setting/getting
204 * CREATE_TIME which was previously unimplemented. (Note that the old C_TIME
205 * was supposed to be CHANGE_TIME but was confused and sometimes referred to
206 * CREATE_TIME.)
207 */
208 smbc_bool
smbc_getOptionFullTimeNames(SMBCCTX * c)209 smbc_getOptionFullTimeNames(SMBCCTX *c)
210 {
211 return c->internal->full_time_names;
212 }
213
214 /**
215 * Set whether to use new-style time attribute names, e.g. WRITE_TIME rather
216 * than the old-style names such as M_TIME. This allows also setting/getting
217 * CREATE_TIME which was previously unimplemented. (Note that the old C_TIME
218 * was supposed to be CHANGE_TIME but was confused and sometimes referred to
219 * CREATE_TIME.)
220 */
221 void
smbc_setOptionFullTimeNames(SMBCCTX * c,smbc_bool b)222 smbc_setOptionFullTimeNames(SMBCCTX *c, smbc_bool b)
223 {
224 c->internal->full_time_names = b;
225 }
226
227 /**
228 * Get the share mode to use for files opened with SMBC_open_ctx(). The
229 * default is SMBC_SHAREMODE_DENY_NONE.
230 */
231 smbc_share_mode
smbc_getOptionOpenShareMode(SMBCCTX * c)232 smbc_getOptionOpenShareMode(SMBCCTX *c)
233 {
234 return c->internal->share_mode;
235 }
236
237 /**
238 * Set the share mode to use for files opened with SMBC_open_ctx(). The
239 * default is SMBC_SHAREMODE_DENY_NONE.
240 */
241 void
smbc_setOptionOpenShareMode(SMBCCTX * c,smbc_share_mode share_mode)242 smbc_setOptionOpenShareMode(SMBCCTX *c, smbc_share_mode share_mode)
243 {
244 c->internal->share_mode = share_mode;
245 }
246
247 /** Retrieve a previously set user data handle */
248 void *
smbc_getOptionUserData(SMBCCTX * c)249 smbc_getOptionUserData(SMBCCTX *c)
250 {
251 return c->internal->user_data;
252 }
253
254 /** Save a user data handle */
255 void
smbc_setOptionUserData(SMBCCTX * c,void * user_data)256 smbc_setOptionUserData(SMBCCTX *c, void *user_data)
257 {
258 c->internal->user_data = user_data;
259 }
260
261 /** Get the encoded value for encryption level. */
262 smbc_smb_encrypt_level
smbc_getOptionSmbEncryptionLevel(SMBCCTX * c)263 smbc_getOptionSmbEncryptionLevel(SMBCCTX *c)
264 {
265 return c->internal->smb_encryption_level;
266 }
267
268 /** Set the encoded value for encryption level. */
269 void
smbc_setOptionSmbEncryptionLevel(SMBCCTX * c,smbc_smb_encrypt_level level)270 smbc_setOptionSmbEncryptionLevel(SMBCCTX *c, smbc_smb_encrypt_level level)
271 {
272 c->internal->smb_encryption_level = level;
273 }
274
275 /**
276 * Get whether to treat file names as case-sensitive if we can't determine
277 * when connecting to the remote share whether the file system is case
278 * sensitive. This defaults to FALSE since it's most likely that if we can't
279 * retrieve the file system attributes, it's a very old file system that does
280 * not support case sensitivity.
281 */
282 smbc_bool
smbc_getOptionCaseSensitive(SMBCCTX * c)283 smbc_getOptionCaseSensitive(SMBCCTX *c)
284 {
285 return c->internal->case_sensitive;
286 }
287
288 /**
289 * Set whether to treat file names as case-sensitive if we can't determine
290 * when connecting to the remote share whether the file system is case
291 * sensitive. This defaults to FALSE since it's most likely that if we can't
292 * retrieve the file system attributes, it's a very old file system that does
293 * not support case sensitivity.
294 */
295 void
smbc_setOptionCaseSensitive(SMBCCTX * c,smbc_bool b)296 smbc_setOptionCaseSensitive(SMBCCTX *c, smbc_bool b)
297 {
298 c->internal->case_sensitive = b;
299 }
300
301 /**
302 * Get from how many local master browsers should the list of workgroups be
303 * retrieved. It can take up to 12 minutes or longer after a server becomes a
304 * local master browser, for it to have the entire browse list (the list of
305 * workgroups/domains) from an entire network. Since a client never knows
306 * which local master browser will be found first, the one which is found
307 * first and used to retrieve a browse list may have an incomplete or empty
308 * browse list. By requesting the browse list from multiple local master
309 * browsers, a more complete list can be generated. For small networks (few
310 * workgroups), it is recommended that this value be set to 0, causing the
311 * browse lists from all found local master browsers to be retrieved and
312 * merged. For networks with many workgroups, a suitable value for this
313 * variable is probably somewhere around 3. (Default: 3).
314 */
315 int
smbc_getOptionBrowseMaxLmbCount(SMBCCTX * c)316 smbc_getOptionBrowseMaxLmbCount(SMBCCTX *c)
317 {
318 return c->options.browse_max_lmb_count;
319 }
320
321 /**
322 * Set from how many local master browsers should the list of workgroups be
323 * retrieved. It can take up to 12 minutes or longer after a server becomes a
324 * local master browser, for it to have the entire browse list (the list of
325 * workgroups/domains) from an entire network. Since a client never knows
326 * which local master browser will be found first, the one which is found
327 * first and used to retrieve a browse list may have an incomplete or empty
328 * browse list. By requesting the browse list from multiple local master
329 * browsers, a more complete list can be generated. For small networks (few
330 * workgroups), it is recommended that this value be set to 0, causing the
331 * browse lists from all found local master browsers to be retrieved and
332 * merged. For networks with many workgroups, a suitable value for this
333 * variable is probably somewhere around 3. (Default: 3).
334 */
335 void
smbc_setOptionBrowseMaxLmbCount(SMBCCTX * c,int count)336 smbc_setOptionBrowseMaxLmbCount(SMBCCTX *c, int count)
337 {
338 c->options.browse_max_lmb_count = count;
339 }
340
341 /**
342 * Get whether to url-encode readdir entries.
343 *
344 * There is a difference in the desired return strings from
345 * smbc_readdir() depending upon whether the filenames are to
346 * be displayed to the user, or whether they are to be
347 * appended to the path name passed to smbc_opendir() to call
348 * a further smbc_ function (e.g. open the file with
349 * smbc_open()). In the former case, the filename should be
350 * in "human readable" form. In the latter case, the smbc_
351 * functions expect a URL which must be url-encoded. Those
352 * functions decode the URL. If, for example, smbc_readdir()
353 * returned a file name of "abc%20def.txt", passing a path
354 * with this file name attached to smbc_open() would cause
355 * smbc_open to attempt to open the file "abc def.txt" since
356 * the %20 is decoded into a space.
357 *
358 * Set this option to True if the names returned by
359 * smbc_readdir() should be url-encoded such that they can be
360 * passed back to another smbc_ call. Set it to False if the
361 * names returned by smbc_readdir() are to be presented to the
362 * user.
363 *
364 * For backwards compatibility, this option defaults to False.
365 */
366 smbc_bool
smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX * c)367 smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX *c)
368 {
369 return c->options.urlencode_readdir_entries;
370 }
371
372 /**
373 * Set whether to url-encode readdir entries.
374 *
375 * There is a difference in the desired return strings from
376 * smbc_readdir() depending upon whether the filenames are to
377 * be displayed to the user, or whether they are to be
378 * appended to the path name passed to smbc_opendir() to call
379 * a further smbc_ function (e.g. open the file with
380 * smbc_open()). In the former case, the filename should be
381 * in "human readable" form. In the latter case, the smbc_
382 * functions expect a URL which must be url-encoded. Those
383 * functions decode the URL. If, for example, smbc_readdir()
384 * returned a file name of "abc%20def.txt", passing a path
385 * with this file name attached to smbc_open() would cause
386 * smbc_open to attempt to open the file "abc def.txt" since
387 * the %20 is decoded into a space.
388 *
389 * Set this option to True if the names returned by
390 * smbc_readdir() should be url-encoded such that they can be
391 * passed back to another smbc_ call. Set it to False if the
392 * names returned by smbc_readdir() are to be presented to the
393 * user.
394 *
395 * For backwards compatibility, this option defaults to False.
396 */
397 void
smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX * c,smbc_bool b)398 smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX *c, smbc_bool b)
399 {
400 c->options.urlencode_readdir_entries = b;
401 }
402
403 /**
404 * Get whether to use the same connection for all shares on a server.
405 *
406 * Some Windows versions appear to have a limit to the number
407 * of concurrent SESSIONs and/or TREE CONNECTions. In
408 * one-shot programs (i.e. the program runs and then quickly
409 * ends, thereby shutting down all connections), it is
410 * probably reasonable to establish a new connection for each
411 * share. In long-running applications, the limitation can be
412 * avoided by using only a single connection to each server,
413 * and issuing a new TREE CONNECT when the share is accessed.
414 */
415 smbc_bool
smbc_getOptionOneSharePerServer(SMBCCTX * c)416 smbc_getOptionOneSharePerServer(SMBCCTX *c)
417 {
418 return c->options.one_share_per_server;
419 }
420
421 /**
422 * Set whether to use the same connection for all shares on a server.
423 *
424 * Some Windows versions appear to have a limit to the number
425 * of concurrent SESSIONs and/or TREE CONNECTions. In
426 * one-shot programs (i.e. the program runs and then quickly
427 * ends, thereby shutting down all connections), it is
428 * probably reasonable to establish a new connection for each
429 * share. In long-running applications, the limitation can be
430 * avoided by using only a single connection to each server,
431 * and issuing a new TREE CONNECT when the share is accessed.
432 */
433 void
smbc_setOptionOneSharePerServer(SMBCCTX * c,smbc_bool b)434 smbc_setOptionOneSharePerServer(SMBCCTX *c, smbc_bool b)
435 {
436 c->options.one_share_per_server = b;
437 }
438
439 /** Get whether to enable use of kerberos */
440 smbc_bool
smbc_getOptionUseKerberos(SMBCCTX * c)441 smbc_getOptionUseKerberos(SMBCCTX *c)
442 {
443 return c->flags & SMB_CTX_FLAG_USE_KERBEROS ? True : False;
444 }
445
446 /** Set whether to enable use of kerberos */
447 void
smbc_setOptionUseKerberos(SMBCCTX * c,smbc_bool b)448 smbc_setOptionUseKerberos(SMBCCTX *c, smbc_bool b)
449 {
450 if (b) {
451 c->flags |= SMB_CTX_FLAG_USE_KERBEROS;
452 } else {
453 c->flags &= ~SMB_CTX_FLAG_USE_KERBEROS;
454 }
455 }
456
457 /** Get whether to fallback after kerberos */
458 smbc_bool
smbc_getOptionFallbackAfterKerberos(SMBCCTX * c)459 smbc_getOptionFallbackAfterKerberos(SMBCCTX *c)
460 {
461 return c->flags & SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS ? True : False;
462 }
463
464 /** Set whether to fallback after kerberos */
465 void
smbc_setOptionFallbackAfterKerberos(SMBCCTX * c,smbc_bool b)466 smbc_setOptionFallbackAfterKerberos(SMBCCTX *c, smbc_bool b)
467 {
468 if (b) {
469 c->flags |= SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
470 } else {
471 c->flags &= ~SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
472 }
473 }
474
475 /** Get whether to automatically select anonymous login */
476 smbc_bool
smbc_getOptionNoAutoAnonymousLogin(SMBCCTX * c)477 smbc_getOptionNoAutoAnonymousLogin(SMBCCTX *c)
478 {
479 return c->flags & SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON ? True : False;
480 }
481
482 /** Set whether to automatically select anonymous login */
483 void
smbc_setOptionNoAutoAnonymousLogin(SMBCCTX * c,smbc_bool b)484 smbc_setOptionNoAutoAnonymousLogin(SMBCCTX *c, smbc_bool b)
485 {
486 if (b) {
487 c->flags |= SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
488 } else {
489 c->flags &= ~SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
490 }
491 }
492
493 /** Get whether to enable use of the winbind ccache */
494 smbc_bool
smbc_getOptionUseCCache(SMBCCTX * c)495 smbc_getOptionUseCCache(SMBCCTX *c)
496 {
497 return c->flags & SMB_CTX_FLAG_USE_CCACHE ? True : False;
498 }
499
500 /** Set whether to enable use of the winbind ccache */
501 void
smbc_setOptionUseCCache(SMBCCTX * c,smbc_bool b)502 smbc_setOptionUseCCache(SMBCCTX *c, smbc_bool b)
503 {
504 if (b) {
505 c->flags |= SMB_CTX_FLAG_USE_CCACHE;
506 } else {
507 c->flags &= ~SMB_CTX_FLAG_USE_CCACHE;
508 }
509 }
510
511 /** Get indication whether the password supplied is the NT hash */
512 smbc_bool
smbc_getOptionUseNTHash(SMBCCTX * c)513 smbc_getOptionUseNTHash(SMBCCTX *c)
514 {
515 return (c->flags & SMB_CTX_FLAG_USE_NT_HASH) != 0;
516 }
517
518 /** Set indication that the password supplied is the NT hash */
519 void
smbc_setOptionUseNTHash(SMBCCTX * c,smbc_bool b)520 smbc_setOptionUseNTHash(SMBCCTX *c, smbc_bool b)
521 {
522 if (b) {
523 c->flags |= SMB_CTX_FLAG_USE_NT_HASH;
524 } else {
525 c->flags &= ~SMB_CTX_FLAG_USE_NT_HASH;
526 }
527 }
528
529 smbc_bool
smbc_setOptionProtocols(SMBCCTX * c,const char * min_proto,const char * max_proto)530 smbc_setOptionProtocols(SMBCCTX *c,
531 const char *min_proto,
532 const char *max_proto)
533 {
534 bool ok = true;
535
536 if (min_proto != NULL) {
537 ok = lp_set_cmdline("client min protocol", min_proto);
538 }
539
540 if (max_proto != NULL) {
541 ok &= lp_set_cmdline("client max protocol", max_proto);
542 }
543
544 return ok;
545 }
546
547 /** Get the function for obtaining authentication data */
548 smbc_get_auth_data_fn
smbc_getFunctionAuthData(SMBCCTX * c)549 smbc_getFunctionAuthData(SMBCCTX *c)
550 {
551 smbc_get_auth_data_fn ret;
552 TALLOC_CTX *frame = talloc_stackframe();
553 ret = c->callbacks.auth_fn;
554 TALLOC_FREE(frame);
555 return ret;
556 }
557
558 /** Set the function for obtaining authentication data */
559 void
smbc_setFunctionAuthData(SMBCCTX * c,smbc_get_auth_data_fn fn)560 smbc_setFunctionAuthData(SMBCCTX *c, smbc_get_auth_data_fn fn)
561 {
562 c->internal->auth_fn_with_context = NULL;
563 c->callbacks.auth_fn = fn;
564 }
565
566 /** Get the new-style authentication function which includes the context. */
567 smbc_get_auth_data_with_context_fn
smbc_getFunctionAuthDataWithContext(SMBCCTX * c)568 smbc_getFunctionAuthDataWithContext(SMBCCTX *c)
569 {
570 return c->internal->auth_fn_with_context;
571 }
572
573 /** Set the new-style authentication function which includes the context. */
574 void
smbc_setFunctionAuthDataWithContext(SMBCCTX * c,smbc_get_auth_data_with_context_fn fn)575 smbc_setFunctionAuthDataWithContext(SMBCCTX *c,
576 smbc_get_auth_data_with_context_fn fn)
577 {
578 c->callbacks.auth_fn = NULL;
579 c->internal->auth_fn_with_context = fn;
580 }
581
582 /** Get the function for checking if a server is still good */
583 smbc_check_server_fn
smbc_getFunctionCheckServer(SMBCCTX * c)584 smbc_getFunctionCheckServer(SMBCCTX *c)
585 {
586 return c->callbacks.check_server_fn;
587 }
588
589 /** Set the function for checking if a server is still good */
590 void
smbc_setFunctionCheckServer(SMBCCTX * c,smbc_check_server_fn fn)591 smbc_setFunctionCheckServer(SMBCCTX *c, smbc_check_server_fn fn)
592 {
593 c->callbacks.check_server_fn = fn;
594 }
595
596 /** Get the function for removing a server if unused */
597 smbc_remove_unused_server_fn
smbc_getFunctionRemoveUnusedServer(SMBCCTX * c)598 smbc_getFunctionRemoveUnusedServer(SMBCCTX *c)
599 {
600 return c->callbacks.remove_unused_server_fn;
601 }
602
603 /** Set the function for removing a server if unused */
604 void
smbc_setFunctionRemoveUnusedServer(SMBCCTX * c,smbc_remove_unused_server_fn fn)605 smbc_setFunctionRemoveUnusedServer(SMBCCTX *c,
606 smbc_remove_unused_server_fn fn)
607 {
608 c->callbacks.remove_unused_server_fn = fn;
609 }
610
611 /** Get the function for adding a cached server */
612 smbc_add_cached_srv_fn
smbc_getFunctionAddCachedServer(SMBCCTX * c)613 smbc_getFunctionAddCachedServer(SMBCCTX *c)
614 {
615 return c->callbacks.add_cached_srv_fn;
616 }
617
618 /** Set the function for adding a cached server */
619 void
smbc_setFunctionAddCachedServer(SMBCCTX * c,smbc_add_cached_srv_fn fn)620 smbc_setFunctionAddCachedServer(SMBCCTX *c, smbc_add_cached_srv_fn fn)
621 {
622 c->callbacks.add_cached_srv_fn = fn;
623 }
624
625 /** Get the function for server cache lookup */
626 smbc_get_cached_srv_fn
smbc_getFunctionGetCachedServer(SMBCCTX * c)627 smbc_getFunctionGetCachedServer(SMBCCTX *c)
628 {
629 return c->callbacks.get_cached_srv_fn;
630 }
631
632 /** Set the function for server cache lookup */
633 void
smbc_setFunctionGetCachedServer(SMBCCTX * c,smbc_get_cached_srv_fn fn)634 smbc_setFunctionGetCachedServer(SMBCCTX *c, smbc_get_cached_srv_fn fn)
635 {
636 c->callbacks.get_cached_srv_fn = fn;
637 }
638
639 /** Get the function for server cache removal */
640 smbc_remove_cached_srv_fn
smbc_getFunctionRemoveCachedServer(SMBCCTX * c)641 smbc_getFunctionRemoveCachedServer(SMBCCTX *c)
642 {
643 return c->callbacks.remove_cached_srv_fn;
644 }
645
646 /** Set the function for server cache removal */
647 void
smbc_setFunctionRemoveCachedServer(SMBCCTX * c,smbc_remove_cached_srv_fn fn)648 smbc_setFunctionRemoveCachedServer(SMBCCTX *c,
649 smbc_remove_cached_srv_fn fn)
650 {
651 c->callbacks.remove_cached_srv_fn = fn;
652 }
653
654 /**
655 * Get the function for server cache purging. This function tries to
656 * remove all cached servers (e.g. on disconnect)
657 */
658 smbc_purge_cached_fn
smbc_getFunctionPurgeCachedServers(SMBCCTX * c)659 smbc_getFunctionPurgeCachedServers(SMBCCTX *c)
660 {
661 return c->callbacks.purge_cached_fn;
662 }
663
664 /** Set the function to store private data of the server cache */
smbc_setServerCacheData(SMBCCTX * c,struct smbc_server_cache * cache)665 void smbc_setServerCacheData(SMBCCTX *c, struct smbc_server_cache * cache)
666 {
667 c->internal->server_cache = cache;
668 }
669
670 /** Get the function to store private data of the server cache */
smbc_getServerCacheData(SMBCCTX * c)671 struct smbc_server_cache * smbc_getServerCacheData(SMBCCTX *c)
672 {
673 return c->internal->server_cache;
674 }
675
676
677 /**
678 * Set the function for server cache purging. This function tries to
679 * remove all cached servers (e.g. on disconnect)
680 */
681 void
smbc_setFunctionPurgeCachedServers(SMBCCTX * c,smbc_purge_cached_fn fn)682 smbc_setFunctionPurgeCachedServers(SMBCCTX *c, smbc_purge_cached_fn fn)
683 {
684 c->callbacks.purge_cached_fn = fn;
685 }
686
687 /**
688 * Callable functions for files.
689 */
690
691 smbc_open_fn
smbc_getFunctionOpen(SMBCCTX * c)692 smbc_getFunctionOpen(SMBCCTX *c)
693 {
694 return c->open;
695 }
696
697 void
smbc_setFunctionOpen(SMBCCTX * c,smbc_open_fn fn)698 smbc_setFunctionOpen(SMBCCTX *c, smbc_open_fn fn)
699 {
700 c->open = fn;
701 }
702
703 smbc_creat_fn
smbc_getFunctionCreat(SMBCCTX * c)704 smbc_getFunctionCreat(SMBCCTX *c)
705 {
706 return c->creat;
707 }
708
709 void
smbc_setFunctionCreat(SMBCCTX * c,smbc_creat_fn fn)710 smbc_setFunctionCreat(SMBCCTX *c, smbc_creat_fn fn)
711 {
712 c->creat = fn;
713 }
714
715 smbc_read_fn
smbc_getFunctionRead(SMBCCTX * c)716 smbc_getFunctionRead(SMBCCTX *c)
717 {
718 return c->read;
719 }
720
721 void
smbc_setFunctionRead(SMBCCTX * c,smbc_read_fn fn)722 smbc_setFunctionRead(SMBCCTX *c, smbc_read_fn fn)
723 {
724 c->read = fn;
725 }
726
727 smbc_write_fn
smbc_getFunctionWrite(SMBCCTX * c)728 smbc_getFunctionWrite(SMBCCTX *c)
729 {
730 return c->write;
731 }
732
733 void
smbc_setFunctionWrite(SMBCCTX * c,smbc_write_fn fn)734 smbc_setFunctionWrite(SMBCCTX *c, smbc_write_fn fn)
735 {
736 c->write = fn;
737 }
738
739 smbc_splice_fn
smbc_getFunctionSplice(SMBCCTX * c)740 smbc_getFunctionSplice(SMBCCTX *c)
741 {
742 return c->internal->smb.splice_fn;
743 }
744
745 void
smbc_setFunctionSplice(SMBCCTX * c,smbc_splice_fn fn)746 smbc_setFunctionSplice(SMBCCTX *c, smbc_splice_fn fn)
747 {
748 c->internal->smb.splice_fn = fn;
749 }
750
751 smbc_unlink_fn
smbc_getFunctionUnlink(SMBCCTX * c)752 smbc_getFunctionUnlink(SMBCCTX *c)
753 {
754 return c->unlink;
755 }
756
757 void
smbc_setFunctionUnlink(SMBCCTX * c,smbc_unlink_fn fn)758 smbc_setFunctionUnlink(SMBCCTX *c, smbc_unlink_fn fn)
759 {
760 c->unlink = fn;
761 }
762
763 smbc_rename_fn
smbc_getFunctionRename(SMBCCTX * c)764 smbc_getFunctionRename(SMBCCTX *c)
765 {
766 return c->rename;
767 }
768
769 void
smbc_setFunctionRename(SMBCCTX * c,smbc_rename_fn fn)770 smbc_setFunctionRename(SMBCCTX *c, smbc_rename_fn fn)
771 {
772 c->rename = fn;
773 }
774
775 smbc_lseek_fn
smbc_getFunctionLseek(SMBCCTX * c)776 smbc_getFunctionLseek(SMBCCTX *c)
777 {
778 return c->lseek;
779 }
780
781 void
smbc_setFunctionLseek(SMBCCTX * c,smbc_lseek_fn fn)782 smbc_setFunctionLseek(SMBCCTX *c, smbc_lseek_fn fn)
783 {
784 c->lseek = fn;
785 }
786
787 smbc_stat_fn
smbc_getFunctionStat(SMBCCTX * c)788 smbc_getFunctionStat(SMBCCTX *c)
789 {
790 return c->stat;
791 }
792
793 void
smbc_setFunctionStat(SMBCCTX * c,smbc_stat_fn fn)794 smbc_setFunctionStat(SMBCCTX *c, smbc_stat_fn fn)
795 {
796 c->stat = fn;
797 }
798
799 smbc_fstat_fn
smbc_getFunctionFstat(SMBCCTX * c)800 smbc_getFunctionFstat(SMBCCTX *c)
801 {
802 return c->fstat;
803 }
804
805 void
smbc_setFunctionFstat(SMBCCTX * c,smbc_fstat_fn fn)806 smbc_setFunctionFstat(SMBCCTX *c, smbc_fstat_fn fn)
807 {
808 c->fstat = fn;
809 }
810
811 smbc_statvfs_fn
smbc_getFunctionStatVFS(SMBCCTX * c)812 smbc_getFunctionStatVFS(SMBCCTX *c)
813 {
814 return c->internal->posix_emu.statvfs_fn;
815 }
816
817 void
smbc_setFunctionStatVFS(SMBCCTX * c,smbc_statvfs_fn fn)818 smbc_setFunctionStatVFS(SMBCCTX *c, smbc_statvfs_fn fn)
819 {
820 c->internal->posix_emu.statvfs_fn = fn;
821 }
822
823 smbc_fstatvfs_fn
smbc_getFunctionFstatVFS(SMBCCTX * c)824 smbc_getFunctionFstatVFS(SMBCCTX *c)
825 {
826 return c->internal->posix_emu.fstatvfs_fn;
827 }
828
829 void
smbc_setFunctionFstatVFS(SMBCCTX * c,smbc_fstatvfs_fn fn)830 smbc_setFunctionFstatVFS(SMBCCTX *c, smbc_fstatvfs_fn fn)
831 {
832 c->internal->posix_emu.fstatvfs_fn = fn;
833 }
834
835 smbc_ftruncate_fn
smbc_getFunctionFtruncate(SMBCCTX * c)836 smbc_getFunctionFtruncate(SMBCCTX *c)
837 {
838 return c->internal->posix_emu.ftruncate_fn;
839 }
840
841 void
smbc_setFunctionFtruncate(SMBCCTX * c,smbc_ftruncate_fn fn)842 smbc_setFunctionFtruncate(SMBCCTX *c, smbc_ftruncate_fn fn)
843 {
844 c->internal->posix_emu.ftruncate_fn = fn;
845 }
846
847 smbc_close_fn
smbc_getFunctionClose(SMBCCTX * c)848 smbc_getFunctionClose(SMBCCTX *c)
849 {
850 return c->close_fn;
851 }
852
853 void
smbc_setFunctionClose(SMBCCTX * c,smbc_close_fn fn)854 smbc_setFunctionClose(SMBCCTX *c, smbc_close_fn fn)
855 {
856 c->close_fn = fn;
857 }
858
859
860 /**
861 * Callable functions for directories.
862 */
863
864 smbc_opendir_fn
smbc_getFunctionOpendir(SMBCCTX * c)865 smbc_getFunctionOpendir(SMBCCTX *c)
866 {
867 return c->opendir;
868 }
869
870 void
smbc_setFunctionOpendir(SMBCCTX * c,smbc_opendir_fn fn)871 smbc_setFunctionOpendir(SMBCCTX *c, smbc_opendir_fn fn)
872 {
873 c->opendir = fn;
874 }
875
876 smbc_closedir_fn
smbc_getFunctionClosedir(SMBCCTX * c)877 smbc_getFunctionClosedir(SMBCCTX *c)
878 {
879 return c->closedir;
880 }
881
882 void
smbc_setFunctionClosedir(SMBCCTX * c,smbc_closedir_fn fn)883 smbc_setFunctionClosedir(SMBCCTX *c, smbc_closedir_fn fn)
884 {
885 c->closedir = fn;
886 }
887
888 smbc_readdir_fn
smbc_getFunctionReaddir(SMBCCTX * c)889 smbc_getFunctionReaddir(SMBCCTX *c)
890 {
891 return c->readdir;
892 }
893
894 void
smbc_setFunctionReaddir(SMBCCTX * c,smbc_readdir_fn fn)895 smbc_setFunctionReaddir(SMBCCTX *c, smbc_readdir_fn fn)
896 {
897 c->readdir = fn;
898 }
899
smbc_getFunctionReaddirPlus(SMBCCTX * c)900 smbc_readdirplus_fn smbc_getFunctionReaddirPlus(SMBCCTX *c)
901 {
902 return c->readdirplus;
903 }
904
smbc_setFunctionReaddirPlus(SMBCCTX * c,smbc_readdirplus_fn fn)905 void smbc_setFunctionReaddirPlus(SMBCCTX *c, smbc_readdirplus_fn fn)
906 {
907 c->readdirplus = fn;
908 }
909
smbc_getFunctionReaddirPlus2(SMBCCTX * c)910 smbc_readdirplus2_fn smbc_getFunctionReaddirPlus2(SMBCCTX *c)
911 {
912 return c->readdirplus2;
913 }
914
smbc_setFunctionReaddirPlus2(SMBCCTX * c,smbc_readdirplus2_fn fn)915 void smbc_setFunctionReaddirPlus2(SMBCCTX *c, smbc_readdirplus2_fn fn)
916 {
917 c->readdirplus2 = fn;
918 }
919
920 smbc_getdents_fn
smbc_getFunctionGetdents(SMBCCTX * c)921 smbc_getFunctionGetdents(SMBCCTX *c)
922 {
923 return c->getdents;
924 }
925
926 void
smbc_setFunctionGetdents(SMBCCTX * c,smbc_getdents_fn fn)927 smbc_setFunctionGetdents(SMBCCTX *c, smbc_getdents_fn fn)
928 {
929 c->getdents = fn;
930 }
931
932 smbc_mkdir_fn
smbc_getFunctionMkdir(SMBCCTX * c)933 smbc_getFunctionMkdir(SMBCCTX *c)
934 {
935 return c->mkdir;
936 }
937
938 void
smbc_setFunctionMkdir(SMBCCTX * c,smbc_mkdir_fn fn)939 smbc_setFunctionMkdir(SMBCCTX *c, smbc_mkdir_fn fn)
940 {
941 c->mkdir = fn;
942 }
943
944 smbc_rmdir_fn
smbc_getFunctionRmdir(SMBCCTX * c)945 smbc_getFunctionRmdir(SMBCCTX *c)
946 {
947 return c->rmdir;
948 }
949
950 void
smbc_setFunctionRmdir(SMBCCTX * c,smbc_rmdir_fn fn)951 smbc_setFunctionRmdir(SMBCCTX *c, smbc_rmdir_fn fn)
952 {
953 c->rmdir = fn;
954 }
955
956 smbc_telldir_fn
smbc_getFunctionTelldir(SMBCCTX * c)957 smbc_getFunctionTelldir(SMBCCTX *c)
958 {
959 return c->telldir;
960 }
961
962 void
smbc_setFunctionTelldir(SMBCCTX * c,smbc_telldir_fn fn)963 smbc_setFunctionTelldir(SMBCCTX *c, smbc_telldir_fn fn)
964 {
965 c->telldir = fn;
966 }
967
968 smbc_lseekdir_fn
smbc_getFunctionLseekdir(SMBCCTX * c)969 smbc_getFunctionLseekdir(SMBCCTX *c)
970 {
971 return c->lseekdir;
972 }
973
974 void
smbc_setFunctionLseekdir(SMBCCTX * c,smbc_lseekdir_fn fn)975 smbc_setFunctionLseekdir(SMBCCTX *c, smbc_lseekdir_fn fn)
976 {
977 c->lseekdir = fn;
978 }
979
980 smbc_fstatdir_fn
smbc_getFunctionFstatdir(SMBCCTX * c)981 smbc_getFunctionFstatdir(SMBCCTX *c)
982 {
983 return c->fstatdir;
984 }
985
986 void
smbc_setFunctionFstatdir(SMBCCTX * c,smbc_fstatdir_fn fn)987 smbc_setFunctionFstatdir(SMBCCTX *c, smbc_fstatdir_fn fn)
988 {
989 c->fstatdir = fn;
990 }
991
992 smbc_notify_fn
smbc_getFunctionNotify(SMBCCTX * c)993 smbc_getFunctionNotify(SMBCCTX *c)
994 {
995 return c->internal->smb.notify_fn;
996 }
997
998 void
smbc_setFunctionNotify(SMBCCTX * c,smbc_notify_fn fn)999 smbc_setFunctionNotify(SMBCCTX *c, smbc_notify_fn fn)
1000 {
1001 c->internal->smb.notify_fn = fn;
1002 }
1003
1004
1005 /**
1006 * Callable functions applicable to both files and directories.
1007 */
1008
1009 smbc_chmod_fn
smbc_getFunctionChmod(SMBCCTX * c)1010 smbc_getFunctionChmod(SMBCCTX *c)
1011 {
1012 return c->chmod;
1013 }
1014
1015 void
smbc_setFunctionChmod(SMBCCTX * c,smbc_chmod_fn fn)1016 smbc_setFunctionChmod(SMBCCTX *c, smbc_chmod_fn fn)
1017 {
1018 c->chmod = fn;
1019 }
1020
1021 smbc_utimes_fn
smbc_getFunctionUtimes(SMBCCTX * c)1022 smbc_getFunctionUtimes(SMBCCTX *c)
1023 {
1024 return c->utimes;
1025 }
1026
1027 void
smbc_setFunctionUtimes(SMBCCTX * c,smbc_utimes_fn fn)1028 smbc_setFunctionUtimes(SMBCCTX *c, smbc_utimes_fn fn)
1029 {
1030 c->utimes = fn;
1031 }
1032
1033 smbc_setxattr_fn
smbc_getFunctionSetxattr(SMBCCTX * c)1034 smbc_getFunctionSetxattr(SMBCCTX *c)
1035 {
1036 return c->setxattr;
1037 }
1038
1039 void
smbc_setFunctionSetxattr(SMBCCTX * c,smbc_setxattr_fn fn)1040 smbc_setFunctionSetxattr(SMBCCTX *c, smbc_setxattr_fn fn)
1041 {
1042 c->setxattr = fn;
1043 }
1044
1045 smbc_getxattr_fn
smbc_getFunctionGetxattr(SMBCCTX * c)1046 smbc_getFunctionGetxattr(SMBCCTX *c)
1047 {
1048 return c->getxattr;
1049 }
1050
1051 void
smbc_setFunctionGetxattr(SMBCCTX * c,smbc_getxattr_fn fn)1052 smbc_setFunctionGetxattr(SMBCCTX *c, smbc_getxattr_fn fn)
1053 {
1054 c->getxattr = fn;
1055 }
1056
1057 smbc_removexattr_fn
smbc_getFunctionRemovexattr(SMBCCTX * c)1058 smbc_getFunctionRemovexattr(SMBCCTX *c)
1059 {
1060 return c->removexattr;
1061 }
1062
1063 void
smbc_setFunctionRemovexattr(SMBCCTX * c,smbc_removexattr_fn fn)1064 smbc_setFunctionRemovexattr(SMBCCTX *c, smbc_removexattr_fn fn)
1065 {
1066 c->removexattr = fn;
1067 }
1068
1069 smbc_listxattr_fn
smbc_getFunctionListxattr(SMBCCTX * c)1070 smbc_getFunctionListxattr(SMBCCTX *c)
1071 {
1072 return c->listxattr;
1073 }
1074
1075 void
smbc_setFunctionListxattr(SMBCCTX * c,smbc_listxattr_fn fn)1076 smbc_setFunctionListxattr(SMBCCTX *c, smbc_listxattr_fn fn)
1077 {
1078 c->listxattr = fn;
1079 }
1080
1081
1082 /**
1083 * Callable functions related to printing
1084 */
1085
1086 smbc_print_file_fn
smbc_getFunctionPrintFile(SMBCCTX * c)1087 smbc_getFunctionPrintFile(SMBCCTX *c)
1088 {
1089 return c->print_file;
1090 }
1091
1092 void
smbc_setFunctionPrintFile(SMBCCTX * c,smbc_print_file_fn fn)1093 smbc_setFunctionPrintFile(SMBCCTX *c, smbc_print_file_fn fn)
1094 {
1095 c->print_file = fn;
1096 }
1097
1098 smbc_open_print_job_fn
smbc_getFunctionOpenPrintJob(SMBCCTX * c)1099 smbc_getFunctionOpenPrintJob(SMBCCTX *c)
1100 {
1101 return c->open_print_job;
1102 }
1103
1104 void
smbc_setFunctionOpenPrintJob(SMBCCTX * c,smbc_open_print_job_fn fn)1105 smbc_setFunctionOpenPrintJob(SMBCCTX *c,
1106 smbc_open_print_job_fn fn)
1107 {
1108 c->open_print_job = fn;
1109 }
1110
1111 smbc_list_print_jobs_fn
smbc_getFunctionListPrintJobs(SMBCCTX * c)1112 smbc_getFunctionListPrintJobs(SMBCCTX *c)
1113 {
1114 return c->list_print_jobs;
1115 }
1116
1117 void
smbc_setFunctionListPrintJobs(SMBCCTX * c,smbc_list_print_jobs_fn fn)1118 smbc_setFunctionListPrintJobs(SMBCCTX *c,
1119 smbc_list_print_jobs_fn fn)
1120 {
1121 c->list_print_jobs = fn;
1122 }
1123
1124 smbc_unlink_print_job_fn
smbc_getFunctionUnlinkPrintJob(SMBCCTX * c)1125 smbc_getFunctionUnlinkPrintJob(SMBCCTX *c)
1126 {
1127 return c->unlink_print_job;
1128 }
1129
1130 void
smbc_setFunctionUnlinkPrintJob(SMBCCTX * c,smbc_unlink_print_job_fn fn)1131 smbc_setFunctionUnlinkPrintJob(SMBCCTX *c,
1132 smbc_unlink_print_job_fn fn)
1133 {
1134 c->unlink_print_job = fn;
1135 }
1136
1137