/home/adnan/Downloads/libsmbclient/libsmbclient-dev_2%3a3.5.11~dfsg-1ubuntu2.1_amd64/usr/include/libsmbclient.h

Go to the documentation of this file.

/*=====================================================================
  Unix SMB/Netbios implementation.
  SMB client library API definitions
  Copyright (C) Andrew Tridgell 1998
  Copyright (C) Richard Sharpe 2000
  Copyright (C) John Terpsra 2000
  Copyright (C) Tom Jansen (Ninja ISD) 2002 
  Copyright (C) Derrell Lipman 2003-2008

   
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.
   
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.
   
  You should have received a copy of the GNU General Public License
  along with this program; if not, see <http://www.gnu.org/licenses/>.
  =====================================================================*/

#ifndef SMBCLIENT_H_INCLUDED
#define SMBCLIENT_H_INCLUDED

#undef DEPRECATED_SMBC_INTERFACE
#if ! defined(__LIBSMBCLIENT_INTERNAL__) && defined(__GNUC__)
# define DEPRECATED_SMBC_INTERFACE      __attribute__ ((deprecated))
#else
# define DEPRECATED_SMBC_INTERFACE
#endif

#ifdef __cplusplus
extern "C" {
#endif

/*-------------------------------------------------------------------*/
/* The following are special comments to instruct DOXYGEN (automated 
 * documentation tool:
*/
/*-------------------------------------------------------------------*/   

/* Make sure we have the following includes for now ... */
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <fcntl.h>
#include <utime.h>

  /* Debian bug #221618 */
#define _LARGEFILE64_SOURCE
#define _FILE_OFFSET_BITS 64

#define SMBC_BASE_FD        10000 /* smallest file descriptor returned */

#define SMBC_WORKGROUP      1
#define SMBC_SERVER         2
#define SMBC_FILE_SHARE     3
#define SMBC_PRINTER_SHARE  4
#define SMBC_COMMS_SHARE    5
#define SMBC_IPC_SHARE      6
#define SMBC_DIR            7
#define SMBC_FILE           8
#define SMBC_LINK           9

struct smbc_dirent 
{
        unsigned int smbc_type; 

        unsigned int dirlen;
        unsigned int commentlen;
        char *comment;
        unsigned int namelen;
        char name[1];
};

/*
 * Flags for smbc_setxattr()
 *   Specify a bitwise OR of these, or 0 to add or replace as necessary
 */
#define SMBC_XATTR_FLAG_CREATE       0x1 /* fail if attr already exists */
#define SMBC_XATTR_FLAG_REPLACE      0x2 /* fail if attr does not exist */


/*
 * Mappings of the DOS mode bits, as returned by smbc_getxattr() when the
 * attribute name "system.dos_attr.mode" (or "system.dos_attr.*" or
 * "system.*") is specified.
 */
#define SMBC_DOS_MODE_READONLY       0x01
#define SMBC_DOS_MODE_HIDDEN         0x02
#define SMBC_DOS_MODE_SYSTEM         0x04
#define SMBC_DOS_MODE_VOLUME_ID      0x08
#define SMBC_DOS_MODE_DIRECTORY      0x10
#define SMBC_DOS_MODE_ARCHIVE        0x20

/*
 * Valid values for the option "open_share_mode", when calling
 * smbc_setOptionOpenShareMode()
 */
typedef enum smbc_share_mode
{
    SMBC_SHAREMODE_DENY_DOS     = 0,
    SMBC_SHAREMODE_DENY_ALL     = 1,
    SMBC_SHAREMODE_DENY_WRITE   = 2,
    SMBC_SHAREMODE_DENY_READ    = 3,
    SMBC_SHAREMODE_DENY_NONE    = 4,
    SMBC_SHAREMODE_DENY_FCB     = 7
} smbc_share_mode;


typedef enum smbc_smb_encrypt_level
{
    SMBC_ENCRYPTLEVEL_NONE      = 0,
    SMBC_ENCRYPTLEVEL_REQUEST   = 1,
    SMBC_ENCRYPTLEVEL_REQUIRE   = 2
} smbc_smb_encrypt_level;


typedef enum smbc_vfs_feature
{
    /* Defined by POSIX or in Linux include files (low-order bits) */
    SMBC_VFS_FEATURE_RDONLY         = (1 << 0),

    /* Specific to libsmbclient (high-order bits) */
    SMBC_VFS_FEATURE_DFS              = (1 << 28),
    SMBC_VFS_FEATURE_CASE_INSENSITIVE = (1 << 29),
    SMBC_VFS_FEATURE_NO_UNIXCIFS      = (1 << 30)
} smbc_vfs_feature;

typedef int smbc_bool;


#ifndef ENOATTR
# define ENOATTR ENOENT        /* No such attribute */
#endif




#ifndef _CLIENT_H
struct print_job_info 
{
        unsigned short id;
    
        unsigned short priority;
    
        size_t size;
    
        char user[128];
  
        char name[128];

        time_t t;
};
#endif /* _CLIENT_H */


typedef struct _SMBCSRV  SMBCSRV;

typedef struct _SMBCFILE SMBCFILE;

typedef struct _SMBCCTX SMBCCTX;


/*
 * Flags for SMBCCTX->flags
 *
 * NEW CODE SHOULD NOT DIRECTLY MANIPULATE THE CONTEXT STRUCTURE.
 * Instead, use:
 *   smbc_setOptionUseKerberos()
 *   smbc_getOptionUseKerberos()
 *   smbc_setOptionFallbackAfterKerberos()
 *   smbc_getOptionFallbackAFterKerberos()
 *   smbc_setOptionNoAutoAnonymousLogin()
 *   smbc_getOptionNoAutoAnonymousLogin()
 *   smbc_setOptionUseCCache()
 *   smbc_getOptionUseCCache()
 */
# define SMB_CTX_FLAG_USE_KERBEROS (1 << 0)
# define SMB_CTX_FLAG_FALLBACK_AFTER_KERBEROS (1 << 1)
# define SMBCCTX_FLAG_NO_AUTO_ANONYMOUS_LOGON (1 << 2)
# define SMB_CTX_FLAG_USE_CCACHE (1 << 3)



typedef void (*smbc_get_auth_data_fn)(const char *srv, 
                                      const char *shr,
                                      char *wg, int wglen, 
                                      char *un, int unlen,
                                      char *pw, int pwlen);
typedef void (*smbc_get_auth_data_with_context_fn)(SMBCCTX *c,
                                                   const char *srv, 
                                                   const char *shr,
                                                   char *wg, int wglen, 
                                                   char *un, int unlen,
                                                   char *pw, int pwlen);


typedef void (*smbc_list_print_job_fn)(struct print_job_info *i);
                

typedef int (*smbc_check_server_fn)(SMBCCTX * c, SMBCSRV *srv);

typedef int (*smbc_remove_unused_server_fn)(SMBCCTX * c, SMBCSRV *srv);


typedef int (*smbc_add_cached_srv_fn)   (SMBCCTX * c, SMBCSRV *srv, 
                                    const char * server, const char * share,
                                    const char * workgroup, const char * username);

typedef SMBCSRV * (*smbc_get_cached_srv_fn)   (SMBCCTX * c, const char * server,
                                               const char * share, const char * workgroup,
                                               const char * username);

typedef int (*smbc_remove_cached_srv_fn)(SMBCCTX * c, SMBCSRV *srv);


typedef int (*smbc_purge_cached_fn)     (SMBCCTX * c);



/*****************************************
 * Getters and setters for CONFIGURATION *
 *****************************************/

int
smbc_getDebug(SMBCCTX *c);

void
smbc_setDebug(SMBCCTX *c, int debug);

char *
smbc_getNetbiosName(SMBCCTX *c);

void
smbc_setNetbiosName(SMBCCTX *c, char * netbios_name);

char *
smbc_getWorkgroup(SMBCCTX *c);

void smbc_setWorkgroup(SMBCCTX *c, char * workgroup);

char *
smbc_getUser(SMBCCTX *c);

void
smbc_setUser(SMBCCTX *c, char * user);

int
smbc_getTimeout(SMBCCTX *c);

void
smbc_setTimeout(SMBCCTX *c, int timeout);



/***********************************
 * Getters and setters for OPTIONS *
 ***********************************/

smbc_bool
smbc_getOptionDebugToStderr(SMBCCTX *c);

void
smbc_setOptionDebugToStderr(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionFullTimeNames(SMBCCTX *c);

void
smbc_setOptionFullTimeNames(SMBCCTX *c, smbc_bool b);

smbc_share_mode
smbc_getOptionOpenShareMode(SMBCCTX *c);

void
smbc_setOptionOpenShareMode(SMBCCTX *c, smbc_share_mode share_mode);

void *
smbc_getOptionUserData(SMBCCTX *c);

void
smbc_setOptionUserData(SMBCCTX *c, void *user_data);

smbc_smb_encrypt_level
smbc_getOptionSmbEncryptionLevel(SMBCCTX *c);

void
smbc_setOptionSmbEncryptionLevel(SMBCCTX *c, smbc_smb_encrypt_level level);

smbc_bool
smbc_getOptionCaseSensitive(SMBCCTX *c);

void
smbc_setOptionCaseSensitive(SMBCCTX *c, smbc_bool b);


int
smbc_getOptionBrowseMaxLmbCount(SMBCCTX *c);

void
smbc_setOptionBrowseMaxLmbCount(SMBCCTX *c, int count);

smbc_bool
smbc_getOptionUrlEncodeReaddirEntries(SMBCCTX *c);

void
smbc_setOptionUrlEncodeReaddirEntries(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionOneSharePerServer(SMBCCTX *c);

void
smbc_setOptionOneSharePerServer(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionUseKerberos(SMBCCTX *c);

void
smbc_setOptionUseKerberos(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionFallbackAfterKerberos(SMBCCTX *c);

void
smbc_setOptionFallbackAfterKerberos(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionNoAutoAnonymousLogin(SMBCCTX *c);

void
smbc_setOptionNoAutoAnonymousLogin(SMBCCTX *c, smbc_bool b);

smbc_bool
smbc_getOptionUseCCache(SMBCCTX *c);

void
smbc_setOptionUseCCache(SMBCCTX *c, smbc_bool b);



/*************************************
 * Getters and setters for FUNCTIONS *
 *************************************/

smbc_get_auth_data_fn smbc_getFunctionAuthData(SMBCCTX *c);

void smbc_setFunctionAuthData(SMBCCTX *c, smbc_get_auth_data_fn fn);

smbc_get_auth_data_with_context_fn
smbc_getFunctionAuthDataWithContext(SMBCCTX *c);

void
smbc_setFunctionAuthDataWithContext(SMBCCTX *c,
                                    smbc_get_auth_data_with_context_fn fn);

smbc_check_server_fn smbc_getFunctionCheckServer(SMBCCTX *c);

void smbc_setFunctionCheckServer(SMBCCTX *c, smbc_check_server_fn fn);

smbc_remove_unused_server_fn smbc_getFunctionRemoveUnusedServer(SMBCCTX *c);

void smbc_setFunctionRemoveUnusedServer(SMBCCTX *c,
                                        smbc_remove_unused_server_fn fn);

smbc_add_cached_srv_fn smbc_getFunctionAddCachedServer(SMBCCTX *c);

void smbc_setFunctionAddCachedServer(SMBCCTX *c, smbc_add_cached_srv_fn fn);

smbc_get_cached_srv_fn smbc_getFunctionGetCachedServer(SMBCCTX *c);

void smbc_setFunctionGetCachedServer(SMBCCTX *c, smbc_get_cached_srv_fn fn);

smbc_remove_cached_srv_fn smbc_getFunctionRemoveCachedServer(SMBCCTX *c);

void smbc_setFunctionRemoveCachedServer(SMBCCTX *c,
                                        smbc_remove_cached_srv_fn fn);

smbc_purge_cached_fn smbc_getFunctionPurgeCachedServers(SMBCCTX *c);

void smbc_setFunctionPurgeCachedServers(SMBCCTX *c,
                                        smbc_purge_cached_fn fn);

struct smbc_server_cache * smbc_getServerCacheData(SMBCCTX *c);

void smbc_setServerCacheData(SMBCCTX *c, struct smbc_server_cache * cache);



/*****************************************************************
 * Callable functions for files.                                 *
 * Each callable has a function signature typedef, a declaration *
 * for the getter, and a declaration for the setter.             *
 *****************************************************************/

typedef SMBCFILE * (*smbc_open_fn)(SMBCCTX *c,
                                   const char *fname,
                                   int flags,
                                   mode_t mode);
smbc_open_fn smbc_getFunctionOpen(SMBCCTX *c);
void smbc_setFunctionOpen(SMBCCTX *c, smbc_open_fn fn);

typedef SMBCFILE * (*smbc_creat_fn)(SMBCCTX *c,
                                    const char *path,
                                    mode_t mode);
smbc_creat_fn smbc_getFunctionCreat(SMBCCTX *c);
void smbc_setFunctionCreat(SMBCCTX *c, smbc_creat_fn);

typedef ssize_t (*smbc_read_fn)(SMBCCTX *c,
                                SMBCFILE *file,
                                void *buf,
                                size_t count);
smbc_read_fn smbc_getFunctionRead(SMBCCTX *c);
void smbc_setFunctionRead(SMBCCTX *c, smbc_read_fn fn);

typedef ssize_t (*smbc_write_fn)(SMBCCTX *c,
                                 SMBCFILE *file,
                                 const void *buf,
                                 size_t count);
smbc_write_fn smbc_getFunctionWrite(SMBCCTX *c);
void smbc_setFunctionWrite(SMBCCTX *c, smbc_write_fn fn);

typedef int (*smbc_unlink_fn)(SMBCCTX *c,
                              const char *fname);
smbc_unlink_fn smbc_getFunctionUnlink(SMBCCTX *c);
void smbc_setFunctionUnlink(SMBCCTX *c, smbc_unlink_fn fn);

typedef int (*smbc_rename_fn)(SMBCCTX *ocontext,
                              const char *oname,
                              SMBCCTX *ncontext,
                              const char *nname);
smbc_rename_fn smbc_getFunctionRename(SMBCCTX *c);
void smbc_setFunctionRename(SMBCCTX *c, smbc_rename_fn fn);

typedef off_t (*smbc_lseek_fn)(SMBCCTX *c,
                               SMBCFILE * file,
                               off_t offset,
                               int whence);
smbc_lseek_fn smbc_getFunctionLseek(SMBCCTX *c);
void smbc_setFunctionLseek(SMBCCTX *c, smbc_lseek_fn fn);

typedef int (*smbc_stat_fn)(SMBCCTX *c,
                            const char *fname,
                            struct stat *st);
smbc_stat_fn smbc_getFunctionStat(SMBCCTX *c);
void smbc_setFunctionStat(SMBCCTX *c, smbc_stat_fn fn);

typedef int (*smbc_fstat_fn)(SMBCCTX *c,
                             SMBCFILE *file,
                             struct stat *st);
smbc_fstat_fn smbc_getFunctionFstat(SMBCCTX *c);
void smbc_setFunctionFstat(SMBCCTX *c, smbc_fstat_fn fn);

typedef int (*smbc_statvfs_fn)(SMBCCTX *c,
                               char *path,
                               struct statvfs *st);
smbc_statvfs_fn smbc_getFunctionStatVFS(SMBCCTX *c);
void smbc_setFunctionStatVFS(SMBCCTX *c, smbc_statvfs_fn fn);

typedef int (*smbc_fstatvfs_fn)(SMBCCTX *c,
                                SMBCFILE *file,
                                struct statvfs *st);
smbc_fstatvfs_fn smbc_getFunctionFstatVFS(SMBCCTX *c);
void smbc_setFunctionFstatVFS(SMBCCTX *c, smbc_fstatvfs_fn fn);

typedef int (*smbc_ftruncate_fn)(SMBCCTX *c,
                                 SMBCFILE *f,
                                 off_t size);
smbc_ftruncate_fn smbc_getFunctionFtruncate(SMBCCTX *c);
void smbc_setFunctionFtruncate(SMBCCTX *c, smbc_ftruncate_fn fn);

typedef int (*smbc_close_fn)(SMBCCTX *c,
                             SMBCFILE *file);
smbc_close_fn smbc_getFunctionClose(SMBCCTX *c);
void smbc_setFunctionClose(SMBCCTX *c, smbc_close_fn fn);



/*****************************************************************
 * Callable functions for directories.                           *
 * Each callable has a function signature typedef, a declaration *
 * for the getter, and a declaration for the setter.             *
 *****************************************************************/

typedef SMBCFILE * (*smbc_opendir_fn)(SMBCCTX *c,
                                      const char *fname);
smbc_opendir_fn smbc_getFunctionOpendir(SMBCCTX *c);
void smbc_setFunctionOpendir(SMBCCTX *c, smbc_opendir_fn fn);

typedef int (*smbc_closedir_fn)(SMBCCTX *c,
                                SMBCFILE *dir);
smbc_closedir_fn smbc_getFunctionClosedir(SMBCCTX *c);
void smbc_setFunctionClosedir(SMBCCTX *c, smbc_closedir_fn fn);

typedef struct smbc_dirent * (*smbc_readdir_fn)(SMBCCTX *c,
                                                SMBCFILE *dir);
smbc_readdir_fn smbc_getFunctionReaddir(SMBCCTX *c);
void smbc_setFunctionReaddir(SMBCCTX *c, smbc_readdir_fn fn);

typedef int (*smbc_getdents_fn)(SMBCCTX *c,
                                SMBCFILE *dir,
                                struct smbc_dirent *dirp,
                                int count);
smbc_getdents_fn smbc_getFunctionGetdents(SMBCCTX *c);
void smbc_setFunctionGetdents(SMBCCTX *c, smbc_getdents_fn fn);

typedef int (*smbc_mkdir_fn)(SMBCCTX *c,
                             const char *fname,
                             mode_t mode);
smbc_mkdir_fn smbc_getFunctionMkdir(SMBCCTX *c);
void smbc_setFunctionMkdir(SMBCCTX *c, smbc_mkdir_fn fn);

typedef int (*smbc_rmdir_fn)(SMBCCTX *c,
                             const char *fname);
smbc_rmdir_fn smbc_getFunctionRmdir(SMBCCTX *c);
void smbc_setFunctionRmdir(SMBCCTX *c, smbc_rmdir_fn fn);

typedef off_t (*smbc_telldir_fn)(SMBCCTX *c,
                                 SMBCFILE *dir);
smbc_telldir_fn smbc_getFunctionTelldir(SMBCCTX *c);
void smbc_setFunctionTelldir(SMBCCTX *c, smbc_telldir_fn fn);

typedef int (*smbc_lseekdir_fn)(SMBCCTX *c,
                                SMBCFILE *dir,
                                off_t offset);
smbc_lseekdir_fn smbc_getFunctionLseekdir(SMBCCTX *c);
void smbc_setFunctionLseekdir(SMBCCTX *c, smbc_lseekdir_fn fn);

typedef int (*smbc_fstatdir_fn)(SMBCCTX *c,
                                SMBCFILE *dir,
                                struct stat *st);
smbc_fstatdir_fn smbc_getFunctionFstatdir(SMBCCTX *c);
void smbc_setFunctionFstatdir(SMBCCTX *c, smbc_fstatdir_fn fn);



/*****************************************************************
 * Callable functions applicable to both files and directories.  *
 * Each callable has a function signature typedef, a declaration *
 * for the getter, and a declaration for the setter.             *
 *****************************************************************/

typedef int (*smbc_chmod_fn)(SMBCCTX *c,
                             const char *fname,
                             mode_t mode);
smbc_chmod_fn smbc_getFunctionChmod(SMBCCTX *c);
void smbc_setFunctionChmod(SMBCCTX *c, smbc_chmod_fn fn);

typedef int (*smbc_utimes_fn)(SMBCCTX *c,
                              const char *fname,
                              struct timeval *tbuf);
smbc_utimes_fn smbc_getFunctionUtimes(SMBCCTX *c);
void smbc_setFunctionUtimes(SMBCCTX *c, smbc_utimes_fn fn);

typedef int (*smbc_setxattr_fn)(SMBCCTX *context,
                                const char *fname,
                                const char *name,
                                const void *value,
                                size_t size,
                                int flags);
smbc_setxattr_fn smbc_getFunctionSetxattr(SMBCCTX *c);
void smbc_setFunctionSetxattr(SMBCCTX *c, smbc_setxattr_fn fn);

typedef int (*smbc_getxattr_fn)(SMBCCTX *context,
                                const char *fname,
                                const char *name,
                                const void *value,
                                size_t size);
smbc_getxattr_fn smbc_getFunctionGetxattr(SMBCCTX *c);
void smbc_setFunctionGetxattr(SMBCCTX *c, smbc_getxattr_fn fn);

typedef int (*smbc_removexattr_fn)(SMBCCTX *context,
                                   const char *fname,
                                   const char *name);
smbc_removexattr_fn smbc_getFunctionRemovexattr(SMBCCTX *c);
void smbc_setFunctionRemovexattr(SMBCCTX *c, smbc_removexattr_fn fn);

typedef int (*smbc_listxattr_fn)(SMBCCTX *context,
                                 const char *fname,
                                 char *list,
                                 size_t size);
smbc_listxattr_fn smbc_getFunctionListxattr(SMBCCTX *c);
void smbc_setFunctionListxattr(SMBCCTX *c, smbc_listxattr_fn fn);



/*****************************************************************
 * Callable functions for printing.                              *
 * Each callable has a function signature typedef, a declaration *
 * for the getter, and a declaration for the setter.             *
 *****************************************************************/

typedef int (*smbc_print_file_fn)(SMBCCTX *c_file,
                                  const char *fname,
                                  SMBCCTX *c_print,
                                  const char *printq);
smbc_print_file_fn smbc_getFunctionPrintFile(SMBCCTX *c);
void smbc_setFunctionPrintFile(SMBCCTX *c, smbc_print_file_fn fn);

typedef SMBCFILE * (*smbc_open_print_job_fn)(SMBCCTX *c,
                                             const char *fname);
smbc_open_print_job_fn smbc_getFunctionOpenPrintJob(SMBCCTX *c);
void smbc_setFunctionOpenPrintJob(SMBCCTX *c,
                                  smbc_open_print_job_fn fn);

typedef int (*smbc_list_print_jobs_fn)(SMBCCTX *c,
                                       const char *fname,
                                       smbc_list_print_job_fn fn);
smbc_list_print_jobs_fn smbc_getFunctionListPrintJobs(SMBCCTX *c);
void smbc_setFunctionListPrintJobs(SMBCCTX *c,
                                   smbc_list_print_jobs_fn fn);

typedef int (*smbc_unlink_print_job_fn)(SMBCCTX *c,
                                        const char *fname,
                                        int id);
smbc_unlink_print_job_fn smbc_getFunctionUnlinkPrintJob(SMBCCTX *c);
void smbc_setFunctionUnlinkPrintJob(SMBCCTX *c,
                                    smbc_unlink_print_job_fn fn);


SMBCCTX * smbc_new_context(void);

int smbc_free_context(SMBCCTX * context, int shutdown_ctx);


void
smbc_option_set(SMBCCTX *context,
                char *option_name,
                ... /* option_value */);

/*
 * @deprecated.  Use smbc_getOption*() functions instead.
 */
void *
smbc_option_get(SMBCCTX *context,
                char *option_name);

SMBCCTX * smbc_init_context(SMBCCTX * context);

int smbc_init(smbc_get_auth_data_fn fn, int debug);

SMBCCTX * smbc_set_context(SMBCCTX * new_context);

int smbc_open(const char *furl, int flags, mode_t mode);

int smbc_creat(const char *furl, mode_t mode);

ssize_t smbc_read(int fd, void *buf, size_t bufsize);


ssize_t smbc_write(int fd, const void *buf, size_t bufsize);


off_t smbc_lseek(int fd, off_t offset, int whence);


int smbc_close(int fd);


int smbc_unlink(const char *furl);


int smbc_rename(const char *ourl, const char *nurl);


int smbc_opendir(const char *durl);


int smbc_closedir(int dh);


int smbc_getdents(unsigned int dh, struct smbc_dirent *dirp, int count);


struct smbc_dirent* smbc_readdir(unsigned int dh);


off_t smbc_telldir(int dh);


int smbc_lseekdir(int fd, off_t offset);

int smbc_mkdir(const char *durl, mode_t mode);


int smbc_rmdir(const char *durl);


int smbc_stat(const char *url, struct stat *st);


int smbc_fstat(int fd, struct stat *st);


int
smbc_statvfs(char *url,
             struct statvfs *st);

int
smbc_fstatvfs(int fd,
              struct statvfs *st);


int smbc_ftruncate(int fd, off_t size);


int smbc_chmod(const char *url, mode_t mode);

int smbc_utimes(const char *url, struct timeval *tbuf);

#ifdef HAVE_UTIME_H

int smbc_utime(const char *fname, struct utimbuf *utbuf);
#endif

int smbc_setxattr(const char *url,
                  const char *name,
                  const void *value,
                  size_t size,
                  int flags);


int smbc_lsetxattr(const char *url,
                   const char *name,
                   const void *value,
                   size_t size,
                   int flags);


int smbc_fsetxattr(int fd,
                   const char *name,
                   const void *value,
                   size_t size,
                   int flags);


int smbc_getxattr(const char *url,
                  const char *name,
                  const void *value,
                  size_t size);


int smbc_lgetxattr(const char *url,
                   const char *name,
                   const void *value,
                   size_t size);


int smbc_fgetxattr(int fd,
                   const char *name,
                   const void *value,
                   size_t size);


int smbc_removexattr(const char *url,
                     const char *name);


int smbc_lremovexattr(const char *url,
                      const char *name);


int smbc_fremovexattr(int fd,
                      const char *name);


int smbc_listxattr(const char *url,
                   char *list,
                   size_t size);

int smbc_llistxattr(const char *url,
                    char *list,
                    size_t size);

int smbc_flistxattr(int fd,
                    char *list,
                    size_t size);

int smbc_print_file(const char *fname, const char *printq);

int smbc_open_print_job(const char *fname);

int smbc_list_print_jobs(const char *purl, smbc_list_print_job_fn fn);

int smbc_unlink_print_job(const char *purl, int id);

int smbc_remove_unused_server(SMBCCTX * context, SMBCSRV * srv);

#ifdef __cplusplus
}
#endif

#ifdef __cplusplus
extern "C" {
#endif
int
smbc_urldecode(char *dest, char * src, size_t max_dest_len);
#ifdef __cplusplus
}
#endif


/*
 * Convert any characters not specifically allowed in a URL into their %xx
 * equivalent.
 *
 * @param dest      A pointer to a buffer in which the resulting encoded
 *                  string should be placed.  Unlike smbc_urldecode(), this
 *                  must be a buffer unique from src.
 * 
 * @param src       A pointer to the buffer containing the string to be encoded.
 *                  Any character not specifically allowed in a URL is converted
 *                  into its hexadecimal value and encoded as %xx.
 *
 * @param max_dest_len
 *                  The size of the buffer pointed to by dest_segment.
 * 
 * @returns         The remaining buffer length.
 */
#ifdef __cplusplus
extern "C" {
#endif
int
smbc_urlencode(char * dest, char * src, int max_dest_len);
#ifdef __cplusplus
}
#endif


#ifdef __cplusplus
extern "C" {
#endif
const char *
smbc_version(void);
#ifdef __cplusplus
}
#endif

void
smbc_set_credentials(const char *workgroup,
                     const char *user,
                     const char *password,
                     smbc_bool use_kerberos,
                     const char *signing_state);

/*
 * Wrapper around smbc_set_credentials.
 * Used to set correct credentials that will
 * be used to connect to DFS target share 
 * in libsmbclient
 */

void
smbc_set_credentials_with_fallback(SMBCCTX *ctx,
                                   const char *workgroup,
                                   const char *user,
                                   const char *password);


void
smbc_thread_posix(void);

void
smbc_thread_impl(
        /* Mutex functions. */
        int (*create_mutex)(const char *lockname,
                            void **pplock,
                            const char *location),
        void (*destroy_mutex)(void *plock,
                              const char *location),
        int (*lock_mutex)(void *plock,
                          int lock_type,
                          const char *location),
    
        /* Thread local storage. */
        int (*create_tls)(const char *keyname,
                          void **ppkey,
                          const char *location),
        void (*destroy_tls)(void **ppkey,
                            const char *location),
        int (*set_tls)(void *pkey,
                       const void *pval,
                       const char *location),
        void *(*get_tls)(void *pkey,
                         const char *location)
        );



struct _SMBCCTX
{
        int     debug DEPRECATED_SMBC_INTERFACE;
        
        char * netbios_name DEPRECATED_SMBC_INTERFACE;

        char * workgroup DEPRECATED_SMBC_INTERFACE;

        char * user DEPRECATED_SMBC_INTERFACE;

        int timeout DEPRECATED_SMBC_INTERFACE;

        smbc_open_fn                    open DEPRECATED_SMBC_INTERFACE;
        smbc_creat_fn                   creat DEPRECATED_SMBC_INTERFACE;
        smbc_read_fn                    read DEPRECATED_SMBC_INTERFACE;
        smbc_write_fn                   write DEPRECATED_SMBC_INTERFACE;
        smbc_unlink_fn                  unlink DEPRECATED_SMBC_INTERFACE;
        smbc_rename_fn                  rename DEPRECATED_SMBC_INTERFACE;
        smbc_lseek_fn                   lseek DEPRECATED_SMBC_INTERFACE;
        smbc_stat_fn                    stat DEPRECATED_SMBC_INTERFACE;
        smbc_fstat_fn                   fstat DEPRECATED_SMBC_INTERFACE;
#if 0 /* internal */
        smbc_ftruncate_fn               ftruncate_fn;
#endif
        smbc_close_fn                   close_fn DEPRECATED_SMBC_INTERFACE;
        smbc_opendir_fn                 opendir DEPRECATED_SMBC_INTERFACE;
        smbc_closedir_fn                closedir DEPRECATED_SMBC_INTERFACE;
        smbc_readdir_fn                 readdir DEPRECATED_SMBC_INTERFACE;
        smbc_getdents_fn                getdents DEPRECATED_SMBC_INTERFACE;
        smbc_mkdir_fn                   mkdir DEPRECATED_SMBC_INTERFACE;
        smbc_rmdir_fn                   rmdir DEPRECATED_SMBC_INTERFACE;
        smbc_telldir_fn                 telldir DEPRECATED_SMBC_INTERFACE;
        smbc_lseekdir_fn                lseekdir DEPRECATED_SMBC_INTERFACE;
        smbc_fstatdir_fn                fstatdir DEPRECATED_SMBC_INTERFACE;
        smbc_chmod_fn                   chmod DEPRECATED_SMBC_INTERFACE;
        smbc_utimes_fn                  utimes DEPRECATED_SMBC_INTERFACE;
        smbc_setxattr_fn                setxattr DEPRECATED_SMBC_INTERFACE;
        smbc_getxattr_fn                getxattr DEPRECATED_SMBC_INTERFACE;
        smbc_removexattr_fn             removexattr DEPRECATED_SMBC_INTERFACE;
        smbc_listxattr_fn               listxattr DEPRECATED_SMBC_INTERFACE;

        /* Printing-related functions */
        smbc_print_file_fn              print_file DEPRECATED_SMBC_INTERFACE;
        smbc_open_print_job_fn          open_print_job DEPRECATED_SMBC_INTERFACE;
        smbc_list_print_jobs_fn         list_print_jobs DEPRECATED_SMBC_INTERFACE;
        smbc_unlink_print_job_fn        unlink_print_job DEPRECATED_SMBC_INTERFACE;

        /*
        ** Callbacks
        *
        * DEPRECATED:
        *
        * See the comment above each field, for the getter and setter
        * functions that should now be used.
        */
        struct _smbc_callbacks
        {
                smbc_get_auth_data_fn auth_fn DEPRECATED_SMBC_INTERFACE;
                
                smbc_check_server_fn check_server_fn DEPRECATED_SMBC_INTERFACE;

                smbc_remove_unused_server_fn remove_unused_server_fn DEPRECATED_SMBC_INTERFACE;

                smbc_add_cached_srv_fn add_cached_srv_fn DEPRECATED_SMBC_INTERFACE;

                smbc_get_cached_srv_fn get_cached_srv_fn DEPRECATED_SMBC_INTERFACE;

                smbc_remove_cached_srv_fn remove_cached_srv_fn DEPRECATED_SMBC_INTERFACE;
                
                smbc_purge_cached_fn purge_cached_fn DEPRECATED_SMBC_INTERFACE;
        } callbacks;

        void * reserved DEPRECATED_SMBC_INTERFACE;

        /*
         * Very old configuration options.
         * 
         * DEPRECATED:
         * Use one of the following functions instead:
         *   smbc_setOptionUseKerberos()
         *   smbc_getOptionUseKerberos()
         *   smbc_setOptionFallbackAfterKerberos()
         *   smbc_getOptionFallbackAfterKerberos()
         *   smbc_setOptionNoAutoAnonymousLogin()
         *   smbc_getOptionNoAutoAnonymousLogin()
         */
        int flags DEPRECATED_SMBC_INTERFACE;
        
        struct _smbc_options {
                int browse_max_lmb_count DEPRECATED_SMBC_INTERFACE;
                int urlencode_readdir_entries DEPRECATED_SMBC_INTERFACE;
                int one_share_per_server DEPRECATED_SMBC_INTERFACE;
        } options DEPRECATED_SMBC_INTERFACE;
        
        struct SMBC_internal_data * internal;
};


#endif /* SMBCLIENT_H_INCLUDED */