source3/libsmb/libsmb_setget.c

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