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