LCOV - code coverage report
Current view: top level - source3/libsmb - libsmb_setget.c (source / functions) Hit Total Coverage
Test: coverage report for abartlet/fix-coverage dd10fb34 Lines: 317 374 84.8 %
Date: 2021-09-23 10:06:22 Functions: 111 133 83.5 %

          Line data    Source code
       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 *
      33         190 : smbc_getNetbiosName(SMBCCTX *c)
      34             : {
      35         190 :         return c->netbios_name;
      36             : }
      37             : 
      38             : /** Set the netbios name used for making connections */
      39             : void
      40         100 : smbc_setNetbiosName(SMBCCTX *c, const char *netbios_name)
      41             : {
      42         100 :         SAFE_FREE(c->netbios_name);
      43         100 :         if (netbios_name) {
      44          68 :                 c->netbios_name = SMB_STRDUP(netbios_name);
      45             :         }
      46         100 : }
      47             : 
      48             : /** Get the workgroup used for making connections */
      49             : const char *
      50        3516 : smbc_getWorkgroup(SMBCCTX *c)
      51             : {
      52        3516 :         return c->workgroup;
      53             : }
      54             : 
      55             : /** Set the workgroup used for making connections */
      56             : void
      57         124 : smbc_setWorkgroup(SMBCCTX *c, const char *workgroup)
      58             : {
      59         124 :         SAFE_FREE(c->workgroup);
      60         124 :         if (workgroup) {
      61          92 :                 c->workgroup = SMB_STRDUP(workgroup);
      62             :         }
      63         124 : }
      64             : 
      65             : /** Get the username used for making connections */
      66             : const char *
      67         212 : smbc_getUser(SMBCCTX *c)
      68             : {
      69         212 :         return c->user;
      70             : }
      71             : 
      72             : /** Set the username used for making connections */
      73             : void
      74         124 : smbc_setUser(SMBCCTX *c, const char *user)
      75             : {
      76         124 :         SAFE_FREE(c->user);
      77         124 :         if (user) {
      78          92 :                 c->user = SMB_STRDUP(user);
      79             :         }
      80         124 : }
      81             : 
      82             : /** Get the debug level */
      83             : int
      84         132 : smbc_getDebug(SMBCCTX *c)
      85             : {
      86         132 :         return c->debug;
      87             : }
      88             : 
      89             : /** Set the debug level */
      90             : void
      91         116 : smbc_setDebug(SMBCCTX *c, int debug)
      92             : {
      93             :         char buf[32];
      94         116 :         TALLOC_CTX *frame = talloc_stackframe();
      95         116 :         snprintf(buf, sizeof(buf), "%d", debug);
      96         116 :         c->debug = debug;
      97         116 :         lp_set_cmdline("log level", buf);
      98         116 :         TALLOC_FREE(frame);
      99         116 : }
     100             : 
     101             : /** set callback function which will be called for logging */
     102             : void
     103           8 : smbc_setLogCallback(SMBCCTX *c, void *private_ptr,
     104             :                     smbc_debug_callback_fn fn)
     105             : {
     106           8 :         debug_set_callback(private_ptr, fn);
     107           8 : }
     108             : 
     109             : /** set configuration file */
     110           8 : int smbc_setConfiguration(SMBCCTX *c, const char *file)
     111             : {
     112             :         bool ok;
     113             : 
     114           8 :         ok = lp_load_client_no_reinit(file);
     115           8 :         if (!ok) {
     116           0 :                 DBG_WARNING("Could not load config file: %s\n", file);
     117           0 :                 errno = ENOENT;
     118           0 :                 return -1;
     119             :         }
     120             : 
     121           8 :         DBG_NOTICE("Configuration loaded successfully: %s\n", file);
     122           8 :         return 0;
     123             : }
     124             : /**
     125             :  * Get the timeout used for waiting on connections and response data
     126             :  * (in milliseconds)
     127             :  */
     128             : int
     129         190 : smbc_getTimeout(SMBCCTX *c)
     130             : {
     131         190 :         return c->timeout;
     132             : }
     133             : 
     134             : /**
     135             :  * Set the timeout used for waiting on connections and response data
     136             :  * (in milliseconds)
     137             :  */
     138             : void
     139          68 : smbc_setTimeout(SMBCCTX *c, int timeout)
     140             : {
     141          68 :         c->timeout = timeout;
     142          68 : }
     143             : 
     144             : /**
     145             :  * Get the TCP port used to connect.
     146             :  */
     147             : uint16_t
     148        1736 : smbc_getPort(SMBCCTX *c)
     149             : {
     150        1736 :         return c->internal->port;
     151             : }
     152             : 
     153             : /**
     154             :  * Set the TCP port used to connect.
     155             :  */
     156             : void
     157          64 : smbc_setPort(SMBCCTX *c, uint16_t port)
     158             : {
     159          64 :         c->internal->port = port;
     160          64 : }
     161             : 
     162             : 
     163             : /** Get whether to log to standard error instead of standard output */
     164             : smbc_bool
     165           4 : smbc_getOptionDebugToStderr(SMBCCTX *c)
     166             : {
     167             :         smbc_bool ret;
     168           4 :         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           4 :         ret = debug_get_output_is_stderr();
     174           4 :         TALLOC_FREE(frame);
     175           4 :         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
     185          28 : smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b)
     186             : {
     187          28 :         TALLOC_CTX *frame = talloc_stackframe();
     188          28 :         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          28 :                 setup_logging("libsmbclient", DEBUG_STDERR);
     197             :         }
     198          28 :         TALLOC_FREE(frame);
     199          28 : }
     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
     209           4 : smbc_getOptionFullTimeNames(SMBCCTX *c)
     210             : {
     211           4 :         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
     222          68 : smbc_setOptionFullTimeNames(SMBCCTX *c, smbc_bool b)
     223             : {
     224          68 :         c->internal->full_time_names = b;
     225          68 : }
     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
     232           4 : smbc_getOptionOpenShareMode(SMBCCTX *c)
     233             : {
     234           4 :         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
     242          68 : smbc_setOptionOpenShareMode(SMBCCTX *c, smbc_share_mode share_mode)
     243             : {
     244          68 :         c->internal->share_mode = share_mode;
     245          68 : }
     246             : 
     247             : /** Retrieve a previously set user data handle */
     248             : void *
     249           4 : smbc_getOptionUserData(SMBCCTX *c)
     250             : {
     251           4 :         return c->internal->user_data;
     252             : }
     253             : 
     254             : /** Save a user data handle */
     255             : void
     256          68 : smbc_setOptionUserData(SMBCCTX *c, void *user_data)
     257             : {
     258          68 :         c->internal->user_data = user_data;
     259          68 : }
     260             : 
     261             : /** Get the encoded value for encryption level. */
     262             : smbc_smb_encrypt_level
     263           4 : smbc_getOptionSmbEncryptionLevel(SMBCCTX *c)
     264             : {
     265           4 :         return c->internal->smb_encryption_level;
     266             : }
     267             : 
     268             : /** Set the encoded value for encryption level. */
     269             : void
     270          68 : smbc_setOptionSmbEncryptionLevel(SMBCCTX *c, smbc_smb_encrypt_level level)
     271             : {
     272          68 :         c->internal->smb_encryption_level = level;
     273          68 : }
     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
     283           4 : smbc_getOptionCaseSensitive(SMBCCTX *c)
     284             : {
     285           4 :         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
     296          68 : smbc_setOptionCaseSensitive(SMBCCTX *c, smbc_bool b)
     297             : {
     298          68 :         c->internal->case_sensitive = b;
     299          68 : }
     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
     316          12 : smbc_getOptionBrowseMaxLmbCount(SMBCCTX *c)
     317             : {
     318          12 :         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
     336          68 : smbc_setOptionBrowseMaxLmbCount(SMBCCTX *c, int count)
     337             : {
     338          68 :         c->options.browse_max_lmb_count = count;
     339          68 : }
     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
     367         838 : smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX *c)
     368             : {
     369         838 :         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
     398          68 : smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX *c, smbc_bool b)
     399             : {
     400          68 :         c->options.urlencode_readdir_entries = b;
     401          68 : }
     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
     416        1300 : smbc_getOptionOneSharePerServer(SMBCCTX *c)
     417             : {
     418        1300 :         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
     434          68 : smbc_setOptionOneSharePerServer(SMBCCTX *c, smbc_bool b)
     435             : {
     436          68 :         c->options.one_share_per_server = b;
     437          68 : }
     438             : 
     439             : /** Get whether to enable use of kerberos */
     440             : smbc_bool
     441        3092 : smbc_getOptionUseKerberos(SMBCCTX *c)
     442             : {
     443        3092 :         return c->flags & SMB_CTX_FLAG_USE_KERBEROS ? True : False;
     444             : }
     445             : 
     446             : /** Set whether to enable use of kerberos */
     447             : void
     448           4 : smbc_setOptionUseKerberos(SMBCCTX *c, smbc_bool b)
     449             : {
     450           4 :         if (b) {
     451           0 :                 c->flags |= SMB_CTX_FLAG_USE_KERBEROS;
     452             :         } else {
     453           4 :                 c->flags &= ~SMB_CTX_FLAG_USE_KERBEROS;
     454             :         }
     455           4 : }
     456             : 
     457             : /** Get whether to fallback after kerberos */
     458             : smbc_bool
     459          58 : smbc_getOptionFallbackAfterKerberos(SMBCCTX *c)
     460             : {
     461          58 :         return c->flags & SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS ? True : False;
     462             : }
     463             : 
     464             : /** Set whether to fallback after kerberos */
     465             : void
     466           4 : smbc_setOptionFallbackAfterKerberos(SMBCCTX *c, smbc_bool b)
     467             : {
     468           4 :         if (b) {
     469           0 :                 c->flags |= SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
     470             :         } else {
     471           4 :                 c->flags &= ~SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS;
     472             :         }
     473           4 : }
     474             : 
     475             : /** Get whether to automatically select anonymous login */
     476             : smbc_bool
     477           6 : smbc_getOptionNoAutoAnonymousLogin(SMBCCTX *c)
     478             : {
     479           6 :         return c->flags & SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON ? True : False;
     480             : }
     481             : 
     482             : /** Set whether to automatically select anonymous login */
     483             : void
     484           4 : smbc_setOptionNoAutoAnonymousLogin(SMBCCTX *c, smbc_bool b)
     485             : {
     486           4 :         if (b) {
     487           4 :                 c->flags |= SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
     488             :         } else {
     489           0 :                 c->flags &= ~SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON;
     490             :         }
     491           4 : }
     492             : 
     493             : /** Get whether to enable use of the winbind ccache */
     494             : smbc_bool
     495        3092 : smbc_getOptionUseCCache(SMBCCTX *c)
     496             : {
     497        3092 :         return c->flags & SMB_CTX_FLAG_USE_CCACHE ? True : False;
     498             : }
     499             : 
     500             : /** Set whether to enable use of the winbind ccache */
     501             : void
     502          68 : smbc_setOptionUseCCache(SMBCCTX *c, smbc_bool b)
     503             : {
     504          68 :         if (b) {
     505          68 :                 c->flags |= SMB_CTX_FLAG_USE_CCACHE;
     506             :         } else {
     507           0 :                 c->flags &= ~SMB_CTX_FLAG_USE_CCACHE;
     508             :         }
     509          68 : }
     510             : 
     511             : /** Get indication whether the password supplied is the NT hash */
     512             : smbc_bool
     513          54 : smbc_getOptionUseNTHash(SMBCCTX *c)
     514             : {
     515          54 :         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
     520           0 : smbc_setOptionUseNTHash(SMBCCTX *c, smbc_bool b)
     521             : {
     522           0 :         if (b) {
     523           0 :                 c->flags |= SMB_CTX_FLAG_USE_NT_HASH;
     524             :         } else {
     525           0 :                 c->flags &= ~SMB_CTX_FLAG_USE_NT_HASH;
     526             :         }
     527           0 : }
     528             : 
     529             : smbc_bool
     530          24 : smbc_setOptionProtocols(SMBCCTX *c,
     531             :                         const char *min_proto,
     532             :                         const char *max_proto)
     533             : {
     534          24 :         bool ok = true;
     535             : 
     536          24 :         if (min_proto != NULL) {
     537          24 :                 ok = lp_set_cmdline("client min protocol", min_proto);
     538             :         }
     539             : 
     540          24 :         if (max_proto != NULL) {
     541          24 :                 ok &= lp_set_cmdline("client max protocol", max_proto);
     542             :         }
     543             : 
     544          24 :         return ok;
     545             : }
     546             : 
     547             : /** Get the function for obtaining authentication data */
     548             : smbc_get_auth_data_fn
     549         144 : smbc_getFunctionAuthData(SMBCCTX *c)
     550             : {
     551             :         smbc_get_auth_data_fn ret;
     552         144 :         TALLOC_CTX *frame = talloc_stackframe();
     553         144 :         ret = c->callbacks.auth_fn;
     554         144 :         TALLOC_FREE(frame);
     555         144 :         return ret;
     556             : }
     557             : 
     558             : /** Set the function for obtaining authentication data */
     559             : void
     560         112 : smbc_setFunctionAuthData(SMBCCTX *c, smbc_get_auth_data_fn fn)
     561             : {
     562         112 :         c->internal->auth_fn_with_context = NULL;
     563         112 :         c->callbacks.auth_fn = fn;
     564         112 : }
     565             : 
     566             : /** Get the new-style authentication function which includes the context. */
     567             : smbc_get_auth_data_with_context_fn
     568          80 : smbc_getFunctionAuthDataWithContext(SMBCCTX *c)
     569             : {
     570          80 :         return c->internal->auth_fn_with_context;
     571             : }
     572             : 
     573             : /** Set the new-style authentication function which includes the context. */
     574             : void
     575           0 : smbc_setFunctionAuthDataWithContext(SMBCCTX *c,
     576             :                                     smbc_get_auth_data_with_context_fn fn)
     577             : {
     578           0 :         c->callbacks.auth_fn = NULL;
     579           0 :         c->internal->auth_fn_with_context = fn;
     580           0 : }
     581             : 
     582             : /** Get the function for checking if a server is still good */
     583             : smbc_check_server_fn
     584        1296 : smbc_getFunctionCheckServer(SMBCCTX *c)
     585             : {
     586        1296 :         return c->callbacks.check_server_fn;
     587             : }
     588             : 
     589             : /** Set the function for checking if a server is still good */
     590             : void
     591          64 : smbc_setFunctionCheckServer(SMBCCTX *c, smbc_check_server_fn fn)
     592             : {
     593          64 :         c->callbacks.check_server_fn = fn;
     594          64 : }
     595             : 
     596             : /** Get the function for removing a server if unused */
     597             : smbc_remove_unused_server_fn
     598           0 : smbc_getFunctionRemoveUnusedServer(SMBCCTX *c)
     599             : {
     600           0 :         return c->callbacks.remove_unused_server_fn;
     601             : }
     602             : 
     603             : /** Set the function for removing a server if unused */
     604             : void
     605          64 : smbc_setFunctionRemoveUnusedServer(SMBCCTX *c,
     606             :                                    smbc_remove_unused_server_fn fn)
     607             : {
     608          64 :         c->callbacks.remove_unused_server_fn = fn;
     609          64 : }
     610             : 
     611             : /** Get the function for adding a cached server */
     612             : smbc_add_cached_srv_fn
     613          54 : smbc_getFunctionAddCachedServer(SMBCCTX *c)
     614             : {
     615          54 :         return c->callbacks.add_cached_srv_fn;
     616             : }
     617             : 
     618             : /** Set the function for adding a cached server */
     619             : void
     620          64 : smbc_setFunctionAddCachedServer(SMBCCTX *c, smbc_add_cached_srv_fn fn)
     621             : {
     622          64 :         c->callbacks.add_cached_srv_fn = fn;
     623          64 : }
     624             : 
     625             : /** Get the function for server cache lookup */
     626             : smbc_get_cached_srv_fn
     627        1450 : smbc_getFunctionGetCachedServer(SMBCCTX *c)
     628             : {
     629        1450 :         return c->callbacks.get_cached_srv_fn;
     630             : }
     631             : 
     632             : /** Set the function for server cache lookup */
     633             : void
     634          64 : smbc_setFunctionGetCachedServer(SMBCCTX *c, smbc_get_cached_srv_fn fn)
     635             : {
     636          64 :         c->callbacks.get_cached_srv_fn = fn;
     637          64 : }
     638             : 
     639             : /** Get the function for server cache removal */
     640             : smbc_remove_cached_srv_fn
     641          22 : smbc_getFunctionRemoveCachedServer(SMBCCTX *c)
     642             : {
     643          22 :         return c->callbacks.remove_cached_srv_fn;
     644             : }
     645             : 
     646             : /** Set the function for server cache removal */
     647             : void
     648          64 : smbc_setFunctionRemoveCachedServer(SMBCCTX *c,
     649             :                                    smbc_remove_cached_srv_fn fn)
     650             : {
     651          64 :         c->callbacks.remove_cached_srv_fn = fn;
     652          64 : }
     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
     659          32 : smbc_getFunctionPurgeCachedServers(SMBCCTX *c)
     660             : {
     661          32 :         return c->callbacks.purge_cached_fn;
     662             : }
     663             : 
     664             : /** Set the function to store private data of the server cache */
     665           0 : void smbc_setServerCacheData(SMBCCTX *c, struct smbc_server_cache * cache)
     666             : {
     667           0 :         c->internal->server_cache = cache;
     668           0 : }
     669             : 
     670             : /** Get the function to store private data of the server cache */
     671           0 : struct smbc_server_cache * smbc_getServerCacheData(SMBCCTX *c)
     672             : {
     673           0 :         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
     682          64 : smbc_setFunctionPurgeCachedServers(SMBCCTX *c, smbc_purge_cached_fn fn)
     683             : {
     684          64 :         c->callbacks.purge_cached_fn = fn;
     685          64 : }
     686             : 
     687             : /**
     688             :  * Callable functions for files.
     689             :  */
     690             : 
     691             : smbc_open_fn
     692          40 : smbc_getFunctionOpen(SMBCCTX *c)
     693             : {
     694          40 :         return c->open;
     695             : }
     696             : 
     697             : void
     698          64 : smbc_setFunctionOpen(SMBCCTX *c, smbc_open_fn fn)
     699             : {
     700          64 :         c->open = fn;
     701          64 : }
     702             : 
     703             : smbc_creat_fn
     704         408 : smbc_getFunctionCreat(SMBCCTX *c)
     705             : {
     706         408 :         return c->creat;
     707             : }
     708             : 
     709             : void
     710          64 : smbc_setFunctionCreat(SMBCCTX *c, smbc_creat_fn fn)
     711             : {
     712          64 :         c->creat = fn;
     713          64 : }
     714             : 
     715             : smbc_read_fn
     716          98 : smbc_getFunctionRead(SMBCCTX *c)
     717             : {
     718          98 :         return c->read;
     719             : }
     720             : 
     721             : void
     722          64 : smbc_setFunctionRead(SMBCCTX *c, smbc_read_fn fn)
     723             : {
     724          64 :         c->read = fn;
     725          64 : }
     726             : 
     727             : smbc_write_fn
     728           0 : smbc_getFunctionWrite(SMBCCTX *c)
     729             : {
     730           0 :         return c->write;
     731             : }
     732             : 
     733             : void
     734          64 : smbc_setFunctionWrite(SMBCCTX *c, smbc_write_fn fn)
     735             : {
     736          64 :         c->write = fn;
     737          64 : }
     738             : 
     739             : smbc_splice_fn
     740           0 : smbc_getFunctionSplice(SMBCCTX *c)
     741             : {
     742           0 :         return c->internal->smb.splice_fn;
     743             : }
     744             : 
     745             : void
     746          64 : smbc_setFunctionSplice(SMBCCTX *c, smbc_splice_fn fn)
     747             : {
     748          64 :         c->internal->smb.splice_fn = fn;
     749          64 : }
     750             : 
     751             : smbc_unlink_fn
     752         820 : smbc_getFunctionUnlink(SMBCCTX *c)
     753             : {
     754         820 :         return c->unlink;
     755             : }
     756             : 
     757             : void
     758          64 : smbc_setFunctionUnlink(SMBCCTX *c, smbc_unlink_fn fn)
     759             : {
     760          64 :         c->unlink = fn;
     761          64 : }
     762             : 
     763             : smbc_rename_fn
     764           0 : smbc_getFunctionRename(SMBCCTX *c)
     765             : {
     766           0 :         return c->rename;
     767             : }
     768             : 
     769             : void
     770          64 : smbc_setFunctionRename(SMBCCTX *c, smbc_rename_fn fn)
     771             : {
     772          64 :         c->rename = fn;
     773          64 : }
     774             : 
     775             : smbc_lseek_fn
     776           2 : smbc_getFunctionLseek(SMBCCTX *c)
     777             : {
     778           2 :         return c->lseek;
     779             : }
     780             : 
     781             : void
     782          64 : smbc_setFunctionLseek(SMBCCTX *c, smbc_lseek_fn fn)
     783             : {
     784          64 :         c->lseek = fn;
     785          64 : }
     786             : 
     787             : smbc_stat_fn
     788           8 : smbc_getFunctionStat(SMBCCTX *c)
     789             : {
     790           8 :         return c->stat;
     791             : }
     792             : 
     793             : void
     794          64 : smbc_setFunctionStat(SMBCCTX *c, smbc_stat_fn fn)
     795             : {
     796          64 :         c->stat = fn;
     797          64 : }
     798             : 
     799             : smbc_fstat_fn
     800          44 : smbc_getFunctionFstat(SMBCCTX *c)
     801             : {
     802          44 :         return c->fstat;
     803             : }
     804             : 
     805             : void
     806          64 : smbc_setFunctionFstat(SMBCCTX *c, smbc_fstat_fn fn)
     807             : {
     808          64 :         c->fstat = fn;
     809          64 : }
     810             : 
     811             : smbc_statvfs_fn
     812           0 : smbc_getFunctionStatVFS(SMBCCTX *c)
     813             : {
     814           0 :         return c->internal->posix_emu.statvfs_fn;
     815             : }
     816             : 
     817             : void
     818          64 : smbc_setFunctionStatVFS(SMBCCTX *c, smbc_statvfs_fn fn)
     819             : {
     820          64 :         c->internal->posix_emu.statvfs_fn = fn;
     821          64 : }
     822             : 
     823             : smbc_fstatvfs_fn
     824           0 : smbc_getFunctionFstatVFS(SMBCCTX *c)
     825             : {
     826           0 :         return c->internal->posix_emu.fstatvfs_fn;
     827             : }
     828             : 
     829             : void
     830          64 : smbc_setFunctionFstatVFS(SMBCCTX *c, smbc_fstatvfs_fn fn)
     831             : {
     832          64 :         c->internal->posix_emu.fstatvfs_fn = fn;
     833          64 : }
     834             : 
     835             : smbc_ftruncate_fn
     836           0 : smbc_getFunctionFtruncate(SMBCCTX *c)
     837             : {
     838           0 :         return c->internal->posix_emu.ftruncate_fn;
     839             : }
     840             : 
     841             : void
     842          64 : smbc_setFunctionFtruncate(SMBCCTX *c, smbc_ftruncate_fn fn)
     843             : {
     844          64 :         c->internal->posix_emu.ftruncate_fn = fn;
     845          64 : }
     846             : 
     847             : smbc_close_fn
     848         450 : smbc_getFunctionClose(SMBCCTX *c)
     849             : {
     850         450 :         return c->close_fn;
     851             : }
     852             : 
     853             : void
     854          64 : smbc_setFunctionClose(SMBCCTX *c, smbc_close_fn fn)
     855             : {
     856          64 :         c->close_fn = fn;
     857          64 : }
     858             : 
     859             : 
     860             : /**
     861             :  * Callable functions for directories.
     862             :  */
     863             : 
     864             : smbc_opendir_fn
     865         114 : smbc_getFunctionOpendir(SMBCCTX *c)
     866             : {
     867         114 :         return c->opendir;
     868             : }
     869             : 
     870             : void
     871          64 : smbc_setFunctionOpendir(SMBCCTX *c, smbc_opendir_fn fn)
     872             : {
     873          64 :         c->opendir = fn;
     874          64 : }
     875             : 
     876             : smbc_closedir_fn
     877          52 : smbc_getFunctionClosedir(SMBCCTX *c)
     878             : {
     879          52 :         return c->closedir;
     880             : }
     881             : 
     882             : void
     883          64 : smbc_setFunctionClosedir(SMBCCTX *c, smbc_closedir_fn fn)
     884             : {
     885          64 :         c->closedir = fn;
     886          64 : }
     887             : 
     888             : smbc_readdir_fn
     889         708 : smbc_getFunctionReaddir(SMBCCTX *c)
     890             : {
     891         708 :         return c->readdir;
     892             : }
     893             : 
     894             : void
     895          64 : smbc_setFunctionReaddir(SMBCCTX *c, smbc_readdir_fn fn)
     896             : {
     897          64 :         c->readdir = fn;
     898          64 : }
     899             : 
     900         902 : smbc_readdirplus_fn smbc_getFunctionReaddirPlus(SMBCCTX *c)
     901             : {
     902         902 :         return c->readdirplus;
     903             : }
     904             : 
     905          64 : void smbc_setFunctionReaddirPlus(SMBCCTX *c, smbc_readdirplus_fn fn)
     906             : {
     907          64 :         c->readdirplus = fn;
     908          64 : }
     909             : 
     910         290 : smbc_readdirplus2_fn smbc_getFunctionReaddirPlus2(SMBCCTX *c)
     911             : {
     912         290 :         return c->readdirplus2;
     913             : }
     914             : 
     915          64 : void smbc_setFunctionReaddirPlus2(SMBCCTX *c, smbc_readdirplus2_fn fn)
     916             : {
     917          64 :         c->readdirplus2 = fn;
     918          64 : }
     919             : 
     920             : smbc_getdents_fn
     921           8 : smbc_getFunctionGetdents(SMBCCTX *c)
     922             : {
     923           8 :         return c->getdents;
     924             : }
     925             : 
     926             : void
     927          64 : smbc_setFunctionGetdents(SMBCCTX *c, smbc_getdents_fn fn)
     928             : {
     929          64 :         c->getdents = fn;
     930          64 : }
     931             : 
     932             : smbc_mkdir_fn
     933           4 : smbc_getFunctionMkdir(SMBCCTX *c)
     934             : {
     935           4 :         return c->mkdir;
     936             : }
     937             : 
     938             : void
     939          64 : smbc_setFunctionMkdir(SMBCCTX *c, smbc_mkdir_fn fn)
     940             : {
     941          64 :         c->mkdir = fn;
     942          64 : }
     943             : 
     944             : smbc_rmdir_fn
     945           8 : smbc_getFunctionRmdir(SMBCCTX *c)
     946             : {
     947           8 :         return c->rmdir;
     948             : }
     949             : 
     950             : void
     951          64 : smbc_setFunctionRmdir(SMBCCTX *c, smbc_rmdir_fn fn)
     952             : {
     953          64 :         c->rmdir = fn;
     954          64 : }
     955             : 
     956             : smbc_telldir_fn
     957           8 : smbc_getFunctionTelldir(SMBCCTX *c)
     958             : {
     959           8 :         return c->telldir;
     960             : }
     961             : 
     962             : void
     963          64 : smbc_setFunctionTelldir(SMBCCTX *c, smbc_telldir_fn fn)
     964             : {
     965          64 :         c->telldir = fn;
     966          64 : }
     967             : 
     968             : smbc_lseekdir_fn
     969          20 : smbc_getFunctionLseekdir(SMBCCTX *c)
     970             : {
     971          20 :         return c->lseekdir;
     972             : }
     973             : 
     974             : void
     975          64 : smbc_setFunctionLseekdir(SMBCCTX *c, smbc_lseekdir_fn fn)
     976             : {
     977          64 :         c->lseekdir = fn;
     978          64 : }
     979             : 
     980             : smbc_fstatdir_fn
     981           0 : smbc_getFunctionFstatdir(SMBCCTX *c)
     982             : {
     983           0 :         return c->fstatdir;
     984             : }
     985             : 
     986             : void
     987          64 : smbc_setFunctionFstatdir(SMBCCTX *c, smbc_fstatdir_fn fn)
     988             : {
     989          64 :         c->fstatdir = fn;
     990          64 : }
     991             : 
     992             : smbc_notify_fn
     993           0 : smbc_getFunctionNotify(SMBCCTX *c)
     994             : {
     995           0 :         return c->internal->smb.notify_fn;
     996             : }
     997             : 
     998             : void
     999          64 : smbc_setFunctionNotify(SMBCCTX *c, smbc_notify_fn fn)
    1000             : {
    1001          64 :         c->internal->smb.notify_fn = fn;
    1002          64 : }
    1003             : 
    1004             : 
    1005             : /**
    1006             :  * Callable functions applicable to both files and directories.
    1007             :  */
    1008             : 
    1009             : smbc_chmod_fn
    1010           0 : smbc_getFunctionChmod(SMBCCTX *c)
    1011             : {
    1012           0 :         return c->chmod;
    1013             : }
    1014             : 
    1015             : void
    1016          64 : smbc_setFunctionChmod(SMBCCTX *c, smbc_chmod_fn fn)
    1017             : {
    1018          64 :         c->chmod = fn;
    1019          64 : }
    1020             : 
    1021             : smbc_utimes_fn
    1022           4 : smbc_getFunctionUtimes(SMBCCTX *c)
    1023             : {
    1024           4 :         return c->utimes;
    1025             : }
    1026             : 
    1027             : void
    1028          64 : smbc_setFunctionUtimes(SMBCCTX *c, smbc_utimes_fn fn)
    1029             : {
    1030          64 :         c->utimes = fn;
    1031          64 : }
    1032             : 
    1033             : smbc_setxattr_fn
    1034           0 : smbc_getFunctionSetxattr(SMBCCTX *c)
    1035             : {
    1036           0 :         return c->setxattr;
    1037             : }
    1038             : 
    1039             : void
    1040          64 : smbc_setFunctionSetxattr(SMBCCTX *c, smbc_setxattr_fn fn)
    1041             : {
    1042          64 :         c->setxattr = fn;
    1043          64 : }
    1044             : 
    1045             : smbc_getxattr_fn
    1046           0 : smbc_getFunctionGetxattr(SMBCCTX *c)
    1047             : {
    1048           0 :         return c->getxattr;
    1049             : }
    1050             : 
    1051             : void
    1052          64 : smbc_setFunctionGetxattr(SMBCCTX *c, smbc_getxattr_fn fn)
    1053             : {
    1054          64 :         c->getxattr = fn;
    1055          64 : }
    1056             : 
    1057             : smbc_removexattr_fn
    1058           0 : smbc_getFunctionRemovexattr(SMBCCTX *c)
    1059             : {
    1060           0 :         return c->removexattr;
    1061             : }
    1062             : 
    1063             : void
    1064          64 : smbc_setFunctionRemovexattr(SMBCCTX *c, smbc_removexattr_fn fn)
    1065             : {
    1066          64 :         c->removexattr = fn;
    1067          64 : }
    1068             : 
    1069             : smbc_listxattr_fn
    1070           0 : smbc_getFunctionListxattr(SMBCCTX *c)
    1071             : {
    1072           0 :         return c->listxattr;
    1073             : }
    1074             : 
    1075             : void
    1076          64 : smbc_setFunctionListxattr(SMBCCTX *c, smbc_listxattr_fn fn)
    1077             : {
    1078          64 :         c->listxattr = fn;
    1079          64 : }
    1080             : 
    1081             : 
    1082             : /**
    1083             :  * Callable functions related to printing
    1084             :  */
    1085             : 
    1086             : smbc_print_file_fn
    1087           0 : smbc_getFunctionPrintFile(SMBCCTX *c)
    1088             : {
    1089           0 :         return c->print_file;
    1090             : }
    1091             : 
    1092             : void
    1093          64 : smbc_setFunctionPrintFile(SMBCCTX *c, smbc_print_file_fn fn)
    1094             : {
    1095          64 :         c->print_file = fn;
    1096          64 : }
    1097             : 
    1098             : smbc_open_print_job_fn
    1099           0 : smbc_getFunctionOpenPrintJob(SMBCCTX *c)
    1100             : {
    1101           0 :         return c->open_print_job;
    1102             : }
    1103             : 
    1104             : void
    1105          64 : smbc_setFunctionOpenPrintJob(SMBCCTX *c,
    1106             :                              smbc_open_print_job_fn fn)
    1107             : {
    1108          64 :         c->open_print_job = fn;
    1109          64 : }
    1110             : 
    1111             : smbc_list_print_jobs_fn
    1112           0 : smbc_getFunctionListPrintJobs(SMBCCTX *c)
    1113             : {
    1114           0 :         return c->list_print_jobs;
    1115             : }
    1116             : 
    1117             : void
    1118          64 : smbc_setFunctionListPrintJobs(SMBCCTX *c,
    1119             :                               smbc_list_print_jobs_fn fn)
    1120             : {
    1121          64 :         c->list_print_jobs = fn;
    1122          64 : }
    1123             : 
    1124             : smbc_unlink_print_job_fn
    1125           0 : smbc_getFunctionUnlinkPrintJob(SMBCCTX *c)
    1126             : {
    1127           0 :         return c->unlink_print_job;
    1128             : }
    1129             : 
    1130             : void
    1131          64 : smbc_setFunctionUnlinkPrintJob(SMBCCTX *c,
    1132             :                                smbc_unlink_print_job_fn fn)
    1133             : {
    1134          64 :         c->unlink_print_job = fn;
    1135          64 : }
    1136             : 

Generated by: LCOV version 1.13