Print this page 
NEX-16604 Windows 10 SMB client exhausts smbauth sockets
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-13644 File access audit logging
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Saso Kiselkov <saso.kiselkov@nexenta.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-4820 intended nbmand locking functionality is confused
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-17542 smb_export_t error message in mdb ::smbshare dcmd
Reviewed by: Joyce McIntosh <joyce.mcintosh@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-16519 Panic while running IOmeter to a pool through an SMB share
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
NEX-2807 Restoring previous versions from snapshots doesn't work with nested folders.
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15958 panic importing CA share after failover
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Include in backports of:
  NEX-9808 SMB3 persistent handles
NEX-15958 panic importing CA share after failover
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Include in backports of:
  NEX-9808 SMB3 persistent handles
NEX-9808 SMB3 persistent handles
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15578 SMB2 durable handle redesign
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15581 SMB keep-alive feature is just noise
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-5665 SMB2 oplock leases
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
NEX-15069 smtorture smb2.create.blob is failed
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15555 SMB2 async redesign
NEX-15061 smtorture smb2.lock.cancel.cancel is failed
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Also follow-up change to:
 NEX-1643 dtrace provider for smbsrv (remove "done2" probes,
 which don't make sense with the new async design)
NEX-9808 SMB3 persistent handles
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15578 SMB2 durable handle redesign
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15581 SMB keep-alive feature is just noise
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-5665 SMB2 oplock leases
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
NEX-15069 smtorture smb2.create.blob is failed
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-15555 SMB2 async redesign
NEX-15061 smtorture smb2.lock.cancel.cancel is failed
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Also follow-up change to:
 NEX-1643 dtrace provider for smbsrv (remove "done2" probes,
 which don't make sense with the new async design)
NEX-10231 SMB logon fails in fksmbd
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
NEX-1643 dtrace provider for smbsrv
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
NEX-9864 Some SMB cancel races remain after NEX-5845
Revert (part of) "NEX-5845 rework SMB immediate cancel"
reverts (part of) commit 7a5da69f6d42b17ebcc95ca3d02925d07a01343e.
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-5273 SMB 3 Encryption
Reviewed by: Gordon Ross <gordon.ross@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
NEX-8495 Panic after SMB flush on a named pipe
Reviewed by: Gordon Ross <gwr@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
NEX-7267 Codenomicon causes panic in smb_authsock_cancel
Reviewed by: Roman Strashkin <roman.strashkin@nexenta.com>
Reviewed by: Rick McNeal <rick.mcneal@nexenta.com>
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
NEX-5844 want SMB2 ioctl FSCTL_SRV_COPYCHUNK
NEX-6124 smb_fsop_read/write should allow file != sr->fid_ofile
NEX-6125 smbtorture invalid response with smb2.ioctl
Reviewed by: Evan Layton <evan.layton@nexenta.com>
Reviewed by: Matt Barden <matt.barden@nexenta.com>
NEX-6041 Should pass the smbtorture lock tests
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
NEX-5845 rework SMB immediate cancel
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
NEX-3553 SMB2/3 durable handles
Reviewed by: Gordon Ross <gwr@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
NEX-5599 SMB needs a pointer-based hash table for durable handles
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-3776 SMB should handle PreviousSessionID
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-5560 smb2 should use 64-bit server-global uids
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-5537 Want reference counts for users, trees...
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-5330 SMB server should combine TCP+NBT session lists
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-5314 SMB server may wait for oplock break ack on disconnected session
Reviewed by: Matt Barden <matt.barden@nexenta.com>
NEX-5312 delete_on_close should be acted on earlier
Reviewed by: Gordon Ross <gwr@nexenta.com>
NEX-3906 Prefer that SMB change notify not tie up a worker thread
NEX-5278 SMB notify should buffer per file handle
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Matt Barden <Matt.Barden@nexenta.com>
NEX-5152 immediate SMB cancel may fail
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Matt Barden <Matt.Barden@nexenta.com>
NEX-4598 SMB2 credit shortage with Mac client
Reviewed by: Bayard Bell <bayard.bell@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Matt Barden <Matt.Barden@nexenta.com>
NEX-4147 Cancelled SMB2 requests sometimes have no response (missed things)
NEX-4083 Upstream changes from illumos 5917 and 5995
Reviewed by: Matt Barden <matt.barden@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Yuri Pankov <yuri.pankov@nexenta.com>
NEX-3738 Should support SMB2_CAP_LARGE_MTU
Reviewed by: Alek Pinchuk <alek@nexenta.com>
Reviewed by: Bayard Bell <bayard.bell@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Matt Barden <Matt.Barden@nexenta.com>
NEX-3620 need upstream cleanups for smbsrv
Reviewed by: Hans Rosenfeld <hans.rosenfeld@nexenta.com>
NEX-3610 CLONE NEX-3591 SMB3 signing
Reviewed by: Gordon Ross <gwr@nexenta.com>
Reviewed by: Dan Fields <dan.fields@nexenta.com>
NEX-3080 SMB1 signing problem with Kerberos auth.
Reviewed by: Bayard Bell <bayard.bell@nexenta.com>
Reviewed by: Dan Fields <dan.fields@nexenta.com>
Reviewed by: Kevin Crowe <kevin.crowe@nexenta.com>
Reviewed by: Matt Barden <Matt.Barden@nexenta.com>
NEX-2781 SMB2 credit handling needs work
NEX-2485 SMB authentication flood handled poorly
SMB-136 Snapshots not visible in Windows previous versions
SMB-55 SMB2 signing
SMB-131 Don't allow setting delete-on-close on non empty dirs
SMB-11 SMB2 message parse & dispatch
SMB-12 SMB2 Negotiate Protocol
SMB-13 SMB2 Session Setup
SMB-14 SMB2 Logoff
SMB-15 SMB2 Tree Connect
SMB-16 SMB2 Tree Disconnect
SMB-17 SMB2 Create
SMB-18 SMB2 Close
SMB-19 SMB2 Flush
SMB-20 SMB2 Read
SMB-21 SMB2 Write
SMB-22 SMB2 Lock/Unlock
SMB-23 SMB2 Ioctl
SMB-24 SMB2 Cancel
SMB-25 SMB2 Echo
SMB-26 SMB2 Query Dir
SMB-27 SMB2 Change Notify
SMB-28 SMB2 Query Info
SMB-29 SMB2 Set Info
SMB-30 SMB2 Oplocks
SMB-53 SMB2 Create Context options
(SMB2 code review cleanup 1, 2, 3)
SMB-74 Process oplock breaks as session requests (part two)
SMB-74 Process oplock breaks as session requests
SMB-56 extended security NTLMSSP, inbound
SMB-39 Use AF_UNIX pipes for RPC
SMB-50 User-mode SMB server
 Includes work by these authors:
 Thomas Keiser <thomas.keiser@nexenta.com>
 Albert Lee <trisk@nexenta.com>
SUP-694 panic on bad mutex in smb_event_wait()
SMB-65 SMB server in non-global zones (data structure changes)
Many things move to the smb_server_t object, and
many functions gain an sv arg (which server).
SMB-65 SMB server in non-global zones (kmem_caches)
common kmem_cache instances across zones
separate GZ-only init from NGZ init
SMB-64 smbsrv workers run at excessively high priority
SMB-63 taskq_create_proc ... TQ_DYNAMIC puts tasks in p0
re #11974 CIFS Share - Tree connect fails from Windows 7 Clients
SUP-599 smb_oplock_acquire thread deadlock
SMB-48 Panic with smbtorture raw.scan-eamax
re #13470 rb4432 Sync some SMB differences from illumos
re #7815 SMB server delivers old modification time...
re #11215 rb3676 sesctl to SGI JBOD hangs in biowait() with a command stuck in mptsas driver
re #10734 NT Trans. Notify returning too quickly
re #10733 Windows 7 directory listing keeps restarting
re #6813 rb1757 port 2976 Child folder visibility through shares
Split Close
Expand all
Collapse all
          --- old/usr/src/uts/common/smbsrv/smb_kproto.h
          +++ new/usr/src/uts/common/smbsrv/smb_kproto.h
↓ open down ↓ 13 lines elided ↑ open up ↑ 
  14   14   * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15   15   * If applicable, add the following below this CDDL HEADER, with the
  16   16   * fields enclosed by brackets "[]" replaced with your own identifying
  17   17   * information: Portions Copyright [yyyy] [name of copyright owner]
  18   18   *
  19   19   * CDDL HEADER END
  20   20   */
  21   21  
  22   22  /*
  23   23   * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
  24      - * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
  25   24   * Copyright 2016 Syneto S.R.L.  All rights reserved.
       25 + * Copyright 2018 Nexenta Systems, Inc.  All rights reserved.
  26   26   */
  27   27  
  28   28  /*
  29   29   * Function prototypes for the SMB module.
  30   30   */
  31   31  
  32   32  #ifndef _SMB_KPROTO_H_
  33   33  #define _SMB_KPROTO_H_
  34   34  
  35   35  #ifdef  __cplusplus
  36   36  extern "C" {
  37   37  #endif
  38   38  
  39   39  #include <sys/types.h>
  40   40  #include <sys/param.h>
       41 +#include <sys/varargs.h>
  41   42  #include <sys/systm.h>
  42   43  #include <sys/debug.h>
  43   44  #include <sys/kmem.h>
  44   45  #include <sys/socket.h>
  45   46  #include <sys/ksocket.h>
  46   47  #include <sys/cred.h>
  47   48  #include <sys/nbmlock.h>
  48   49  #include <sys/sunddi.h>
  49   50  #include <sys/atomic.h>
  50   51  #include <smbsrv/smb.h>
  51   52  #include <smbsrv/string.h>
  52   53  #include <smbsrv/smb_vops.h>
  53   54  #include <smbsrv/smb_xdr.h>
  54   55  #include <smbsrv/smb_token.h>
  55   56  #include <smbsrv/smb_ktypes.h>
  56   57  #include <smbsrv/smb_ioctl.h>
  57   58  
  58      -/*
  59      - * DTrace SDT probes have different signatures in userland than they do in
  60      - * kernel.  If we're compiling for user mode (libfksmbsrv) define them as
  61      - * either no-op (for the SMB dtrace provider) or libfksmbsrv functions for
  62      - * the other SDT probe sites.
  63      - */
  64      -#ifndef _KERNEL
  65      -
  66      -extern void smb_dtrace1(const char *f, const char *n,
  67      -                        const char *t1, long v1);
  68      -extern void smb_dtrace2(const char *f, const char *n,
  69      -                        const char *t1, long v1,
  70      -                        const char *t2, long v2);
  71      -extern void smb_dtrace3(const char *f, const char *n,
  72      -                        const char *t1, long v1,
  73      -                        const char *t2, long v2,
  74      -                        const char *t3, long v3);
  75      -
  76      -/*
  77      - * These are for the SMB dtrace proivder, which for a user-mode build
  78      - * are largely redundant with the fbt probes so make these no-ops.
  79      - */
  80      -#undef  DTRACE_SMB_1
  81      -#define DTRACE_SMB_1(n, a, b)                   ((void)b)
  82      -#undef  DTRACE_SMB_2
  83      -#define DTRACE_SMB_2(n, a, b, c, d)             ((void)b, (void)d)
  84      -
  85      -/*
  86      - * These are for the other (specialized) dtrace SDT probes sprinkled
  87      - * through the smbsrv code.  In libfksmbsrv map these to functions.
  88      - */
  89      -
  90      -#undef  DTRACE_PROBE1
  91      -#define DTRACE_PROBE1(n, a, b) \
  92      -        smb_dtrace1(__func__, #n, #a, (long)b)
  93      -
  94      -#undef  DTRACE_PROBE2
  95      -#define DTRACE_PROBE2(n, a, b, c, d) \
  96      -        smb_dtrace2(__func__, #n, #a, (long)b, #c, (long)d)
  97      -
  98      -#undef  DTRACE_PROBE3
  99      -#define DTRACE_PROBE3(n, a, b, c, d, e, f) \
 100      -        smb_dtrace3(__func__, #n, #a, (long)b, #c, (long)d, #e, (long)f)
 101      -
 102      -#endif  /* _KERNEL */
 103      -
 104   59  extern  int smb_maxbufsize;
 105   60  extern  int smb_flush_required;
 106   61  extern  int smb_dirsymlink_enable;
 107      -extern  int smb_oplock_levelII;
 108      -extern  int smb_oplock_timeout;
 109      -extern  int smb_oplock_min_timeout;
 110   62  extern  int smb_shortnames;
 111   63  extern  int smb_sign_debug;
 112      -extern  int smb_raw_mode;
 113   64  extern  uint_t smb_audit_flags;
 114   65  extern  int smb_ssetup_threshold;
 115   66  extern  int smb_tcon_threshold;
 116   67  extern  int smb_opipe_threshold;
 117   68  extern  int smb_ssetup_timeout;
 118   69  extern  int smb_tcon_timeout;
 119   70  extern  int smb_opipe_timeout;
       71 +extern  int smb_allow_advisory_locks;
 120   72  extern const uint32_t smb_vop_dosattr_settable;
 121   73  
 122   74  /* Thread priorities - see smb_init.c */
 123   75  extern  int smbsrv_base_pri;
 124   76  extern  int smbsrv_listen_pri;
 125   77  extern  int smbsrv_receive_pri;
 126   78  extern  int smbsrv_worker_pri;
 127   79  extern  int smbsrv_notify_pri;
 128   80  extern  int smbsrv_timer_pri;
 129   81  
 130   82  extern  kmem_cache_t            *smb_cache_request;
 131   83  extern  kmem_cache_t            *smb_cache_session;
 132   84  extern  kmem_cache_t            *smb_cache_user;
 133   85  extern  kmem_cache_t            *smb_cache_tree;
 134   86  extern  kmem_cache_t            *smb_cache_ofile;
 135   87  extern  kmem_cache_t            *smb_cache_odir;
 136   88  extern  kmem_cache_t            *smb_cache_opipe;
 137   89  extern  kmem_cache_t            *smb_cache_event;
       90 +extern  kmem_cache_t            *smb_cache_lock;
 138   91  
 139   92  extern  kmem_cache_t            *smb_kshare_cache_vfs;
 140   93  
 141   94  time_t smb_get_boottime(void);
 142   95  int smb_server_lookup(smb_server_t **);
 143   96  void smb_server_release(smb_server_t *);
 144   97  
 145   98  /*
 146   99   * SMB request handers called from the dispatcher.  Each SMB request
 147  100   * is handled in three phases: pre, com (command) and post.
↓ open down ↓ 123 lines elided ↑ open up ↑ 
 271  224  uint32_t smb_quota_decode_sids(mbuf_chain_t *, list_t *);
 272  225  void smb_quota_free_sids(smb_quota_query_t *);
 273  226  void smb_quota_max_quota(mbuf_chain_t *, smb_quota_query_t *);
 274  227  uint32_t smb_quota_decode_quotas(mbuf_chain_t *, list_t *);
 275  228  uint32_t smb_quota_encode_quotas(mbuf_chain_t *, smb_quota_query_t *,
 276  229      smb_quota_response_t *, smb_ofile_t *);
 277  230  void smb_quota_free_quotas(list_t *);
 278  231  
 279  232  void smb_query_shortname(smb_node_t *, smb_queryinfo_t *);
 280  233  
      234 +uint32_t smb_dfs_fsctl(smb_request_t *, smb_fsctl_t *);
 281  235  uint32_t smb_dfs_get_referrals(smb_request_t *, smb_fsctl_t *);
 282  236  
 283  237  int smb1_newrq_negotiate(smb_request_t *);
 284  238  smb_sdrc_t smb1_negotiate_smb2(smb_request_t *sr);
 285  239  
 286  240  uint32_t smb_set_basic_info(smb_request_t *, smb_setinfo_t *);
 287  241  uint32_t smb_set_eof_info(smb_request_t *, smb_setinfo_t *);
 288  242  uint32_t smb_set_alloc_info(smb_request_t *, smb_setinfo_t *);
 289  243  uint32_t smb_set_disposition_info(smb_request_t *, smb_setinfo_t *);
 290  244
↓ open down ↓ 1 lines elided ↑ open up ↑ 
 292  246  uint32_t smb_common_rename(smb_request_t *, smb_fqi_t *, smb_fqi_t *);
 293  247  
 294  248  uint32_t smb_setinfo_link(smb_request_t *, smb_node_t *, char *, int);
 295  249  uint32_t smb_make_link(smb_request_t *, smb_fqi_t *, smb_fqi_t *);
 296  250  
 297  251  
 298  252  /*
 299  253   * Logging functions
 300  254   */
 301  255  void smb_log_flush(void);
 302      -void smb_correct_keep_alive_values(uint32_t new_keep_alive);
 303  256  void smb_close_all_connections(void);
 304  257  
 305  258  int smb_net_id(uint32_t);
 306  259  
 307  260  /*
 308      - * oplock functions - node operations
      261 + * Common oplock functions
 309  262   */
 310      -void smb_oplock_acquire(smb_request_t *sr, smb_node_t *, smb_ofile_t *);
 311      -void smb_oplock_release(smb_node_t *, smb_ofile_t *);
 312      -int smb_oplock_break(smb_request_t *, smb_node_t *, uint32_t);
 313      -void smb_oplock_break_levelII(smb_node_t *);
 314      -void smb_oplock_ack(smb_node_t *, smb_ofile_t *, uint8_t);
 315      -void smb_oplock_broadcast(smb_node_t *);
      263 +uint32_t smb_oplock_request(smb_request_t *, smb_ofile_t *, uint32_t *);
      264 +uint32_t smb_oplock_ack_break(smb_request_t *, smb_ofile_t *, uint32_t *);
      265 +uint32_t smb_oplock_break_PARENT(smb_node_t *, smb_ofile_t *);
      266 +uint32_t smb_oplock_break_OPEN(smb_node_t *, smb_ofile_t *,
      267 +    uint32_t DesiredAccess, uint32_t CreateDisposition);
      268 +uint32_t smb_oplock_break_BATCH(smb_node_t *, smb_ofile_t *,
      269 +    uint32_t DesiredAccess, uint32_t CreateDisposition);
      270 +uint32_t smb_oplock_break_HANDLE(smb_node_t *, smb_ofile_t *);
      271 +void smb_oplock_break_CLOSE(smb_node_t *, smb_ofile_t *);
      272 +uint32_t smb_oplock_break_READ(smb_node_t *, smb_ofile_t *);
      273 +uint32_t smb_oplock_break_WRITE(smb_node_t *, smb_ofile_t *);
      274 +uint32_t smb_oplock_break_SETINFO(smb_node_t *,
      275 +    smb_ofile_t *ofile, uint32_t InfoClass);
      276 +uint32_t smb_oplock_break_DELETE(smb_node_t *, smb_ofile_t *);
 316  277  
 317      -void smb1_oplock_break_notification(smb_request_t *, uint8_t);
 318      -void smb2_oplock_break_notification(smb_request_t *, uint8_t);
      278 +void smb_oplock_move(smb_node_t *, smb_ofile_t *, smb_ofile_t *);
 319  279  
 320  280  /*
      281 + * Protocol-specific oplock functions
      282 + * (and "server-level" functions)
      283 + */
      284 +void smb1_oplock_acquire(smb_request_t *, boolean_t);
      285 +void smb1_oplock_break_notification(smb_request_t *, uint32_t);
      286 +void smb2_oplock_break_notification(smb_request_t *, uint32_t);
      287 +void smb2_lease_break_notification(smb_request_t *, uint32_t, boolean_t);
      288 +void smb_oplock_ind_break(smb_ofile_t *, uint32_t, boolean_t, uint32_t);
      289 +void smb_oplock_ind_break_in_ack(smb_request_t *, smb_ofile_t *,
      290 +    uint32_t, boolean_t);
      291 +void smb_oplock_send_brk(smb_request_t *);
      292 +uint32_t smb_oplock_wait_break(smb_node_t *, int);
      293 +
      294 +/*
 321  295   * range lock functions - node operations
 322  296   */
 323  297  uint32_t smb_lock_get_lock_count(smb_node_t *, smb_ofile_t *);
 324      -uint32_t smb_unlock_range(smb_request_t *, smb_node_t *,
 325      -    uint64_t, uint64_t);
      298 +uint32_t smb_unlock_range(smb_request_t *, uint64_t, uint64_t, uint32_t);
 326  299  uint32_t smb_lock_range(smb_request_t *, uint64_t, uint64_t, uint32_t,
 327      -    uint32_t locktype);
      300 +    uint32_t, uint32_t);
      301 +uint32_t smb_lock_range_cancel(smb_request_t *, uint64_t, uint64_t, uint32_t);
 328  302  void smb_lock_range_error(smb_request_t *, uint32_t);
      303 +
      304 +int smb_lock_range_access(smb_request_t *, smb_node_t *,
      305 +    uint64_t, uint64_t, boolean_t);
      306 +
 329  307  DWORD smb_nbl_conflict(smb_node_t *, uint64_t, uint64_t, nbl_op_t);
 330  308  
 331  309  void smb_mangle(const char *, ino64_t, char *, size_t);
 332  310  int smb_unmangle(smb_node_t *, char *, char *, int, uint32_t);
 333  311  boolean_t smb_needs_mangled(const char *);
 334  312  boolean_t smb_maybe_mangled(char *);
 335  313  boolean_t smb_is_reserved_dos_name(const char *);
 336  314  boolean_t smb_is_invalid_filename(const char *);
 337  315  
 338  316  void smbsr_cleanup(smb_request_t *sr);
↓ open down ↓ 5 lines elided ↑ open up ↑ 
 344  322  void    smb_convert_wildcards(char *);
 345  323  boolean_t smb_contains_wildcards(const char *);
 346  324  int     smb_ascii_or_unicode_strlen(smb_request_t *, char *);
 347  325  int     smb_ascii_or_unicode_strlen_null(smb_request_t *, char *);
 348  326  int     smb_ascii_or_unicode_null_len(smb_request_t *);
 349  327  
 350  328  int     smb_search(smb_request_t *);
 351  329  
 352  330  uint32_t smb_common_create(smb_request_t *);
 353  331  uint32_t smb_common_open(smb_request_t *);
      332 +
 354  333  int smb_common_write(smb_request_t *, smb_rw_param_t *);
 355  334  
 356  335  void smb_pathname_init(smb_request_t *, smb_pathname_t *, char *);
 357  336  boolean_t smb_pathname_validate(smb_request_t *, smb_pathname_t *);
 358  337  boolean_t smb_validate_dirname(smb_request_t *, smb_pathname_t *);
 359  338  boolean_t smb_validate_object_name(smb_request_t *, smb_pathname_t *);
 360  339  boolean_t smb_validate_stream_name(smb_request_t *, smb_pathname_t *);
 361  340  boolean_t smb_is_stream_name(char *);
      341 +boolean_t smb_strname_restricted(char *);
      342 +
 362  343  void smb_stream_parse_name(char *, char *, char *);
 363  344  
 364  345  
 365  346  uint32_t smb_omode_to_amask(uint32_t desired_access);
 366  347  
 367  348  void    sshow_distribution_info(char *);
 368  349  
 369      -uint32_t smb2sr_go_async(smb_request_t *sr,
 370      -        smb_sdrc_t (*async_func)(smb_request_t *));
 371      -
 372  350  void    smb_dispatch_stats_init(smb_server_t *);
 373  351  void    smb_dispatch_stats_fini(smb_server_t *);
 374  352  void    smb_dispatch_stats_update(smb_server_t *,
 375  353                  smb_kstat_req_t *, int, int);
 376  354  
 377  355  int     smb1sr_newrq(smb_request_t *);
      356 +int     smb1sr_newrq_cancel(smb_request_t *);
 378  357  void    smb1sr_work(smb_request_t *);
 379  358  
 380  359  int     smbsr_encode_empty_result(smb_request_t *);
 381  360  void    smbsr_lookup_file(smb_request_t *);
 382  361  void    smbsr_release_file(smb_request_t *);
 383  362  
 384  363  int     smbsr_decode_vwv(smb_request_t *sr, const char *, ...);
 385  364  int     smbsr_decode_data(smb_request_t *sr, const char *, ...);
 386  365  boolean_t smbsr_decode_data_avail(smb_request_t *);
 387  366  int     smbsr_encode_result(smb_request_t *, int, int, const char *, ...);
↓ open down ↓ 15 lines elided ↑ open up ↑ 
 403  382  int     clock_get_milli_uptime(void);
 404  383  
 405  384  int     smb_mbc_vencodef(mbuf_chain_t *, const char *, va_list);
 406  385  int     smb_mbc_vdecodef(mbuf_chain_t *, const char *, va_list);
 407  386  int     smb_mbc_decodef(mbuf_chain_t *, const char *, ...);
 408  387  int     smb_mbc_encodef(mbuf_chain_t *, const char *, ...);
 409  388  int     smb_mbc_peek(mbuf_chain_t *, int, const char *, ...);
 410  389  int     smb_mbc_poke(mbuf_chain_t *, int, const char *, ...);
 411  390  int     smb_mbc_put_mem(mbuf_chain_t *, void *, int);
 412  391  int     smb_mbc_copy(mbuf_chain_t *, const mbuf_chain_t *, int, int);
      392 +int     smb_mbc_put_align(mbuf_chain_t *, int);
 413  393  
 414  394  void    smbsr_encode_header(smb_request_t *sr, int wct,
 415  395                      int bcc, const char *fmt, ...);
 416  396  
 417      -int smb_lock_range_access(smb_request_t *, smb_node_t *,
 418      -    uint64_t, uint64_t, boolean_t);
 419      -
 420  397  void smb_encode_sd(mbuf_chain_t *, smb_sd_t *, uint32_t);
 421  398  void smb_encode_sid(mbuf_chain_t *, smb_sid_t *);
 422  399  smb_sid_t *smb_decode_sid(mbuf_chain_t *, uint32_t);
 423  400  uint32_t smb_decode_sd(mbuf_chain_t *, smb_sd_t *);
 424  401  
 425  402  uint32_t smb_pad_align(uint32_t, uint32_t);
 426  403  
 427  404  /*
 428  405   * Socket functions
 429  406   */
↓ open down ↓ 2 lines elided ↑ open up ↑ 
 432  409  void smb_sodestroy(ksocket_t so);
 433  410  int smb_sorecv(ksocket_t so, void *msg, size_t len);
 434  411  void smb_net_txl_constructor(smb_txlst_t *);
 435  412  void smb_net_txl_destructor(smb_txlst_t *);
 436  413  int smb_net_send_uio(smb_session_t *, struct uio *);
 437  414  
 438  415  /*
 439  416   * SMB RPC interface
 440  417   */
 441  418  void smb_opipe_dealloc(smb_opipe_t *);
 442      -int smb_opipe_open(smb_request_t *, uint32_t);
      419 +int smb_opipe_open(smb_request_t *, smb_ofile_t *);
 443  420  void smb_opipe_close(smb_ofile_t *);
 444  421  int smb_opipe_read(smb_request_t *, struct uio *);
 445  422  int smb_opipe_write(smb_request_t *, struct uio *);
 446  423  int smb_opipe_getattr(smb_ofile_t *, smb_attr_t *);
 447  424  int smb_opipe_getname(smb_ofile_t *, char *, size_t);
 448  425  uint32_t smb_opipe_fsctl(smb_request_t *, smb_fsctl_t *);
      426 +uint32_t smb_opipe_transceive(smb_request_t *, smb_fsctl_t *);
 449  427  
 450  428  void smb_kdoor_init(smb_server_t *);
 451  429  void smb_kdoor_fini(smb_server_t *);
 452  430  int smb_kdoor_open(smb_server_t *, int);
 453  431  void smb_kdoor_close(smb_server_t *);
 454  432  int smb_kdoor_upcall(smb_server_t *, uint32_t,
 455  433          void *, xdrproc_t, void *, xdrproc_t);
 456  434  void fksmb_kdoor_open(smb_server_t *, void *);
 457  435  
 458  436  /*
 459  437   * SMB server functions (file smb_server.c)
 460  438   */
 461  439  int smb_server_get_count(void);
 462  440  int smb_server_g_init(void);
 463  441  void smb_server_g_fini(void);
 464  442  int smb_server_create(void);
 465      -int smb_server_delete(void);
      443 +int smb_server_delete(smb_server_t *);
 466  444  int smb_server_configure(smb_ioc_cfg_t *);
 467  445  int smb_server_start(smb_ioc_start_t *);
 468  446  int smb_server_stop(void);
 469  447  boolean_t smb_server_is_stopping(smb_server_t *);
 470  448  void smb_server_cancel_event(smb_server_t *, uint32_t);
 471  449  int smb_server_notify_event(smb_ioc_event_t *);
 472  450  uint32_t smb_server_get_session_count(smb_server_t *);
 473  451  int smb_server_set_gmtoff(smb_ioc_gmt_t *);
 474  452  int smb_server_numopen(smb_ioc_opennum_t *);
 475  453  int smb_server_enum(smb_ioc_svcenum_t *);
 476  454  int smb_server_session_close(smb_ioc_session_t *);
 477  455  int smb_server_file_close(smb_ioc_fileid_t *);
 478      -int smb_server_sharevp(smb_server_t *, const char *, vnode_t **);
      456 +int smb_server_share_lookup(smb_server_t *, const char *, smb_node_t **);
 479  457  int smb_server_unshare(const char *);
 480  458  
      459 +smb_user_t *smb_server_lookup_ssnid(smb_server_t *, uint64_t);
      460 +
 481  461  void smb_server_get_cfg(smb_server_t *, smb_kmod_cfg_t *);
 482  462  
 483  463  int smb_server_spooldoc(smb_ioc_spooldoc_t *);
 484  464  int smb_spool_add_doc(smb_tree_t *, smb_kspooldoc_t *);
 485  465  void smb_spool_add_fid(smb_server_t *, uint16_t);
 486  466  
 487  467  void smb_server_inc_nbt_sess(smb_server_t *);
 488  468  void smb_server_dec_nbt_sess(smb_server_t *);
 489  469  void smb_server_inc_tcp_sess(smb_server_t *);
 490  470  void smb_server_dec_tcp_sess(smb_server_t *);
↓ open down ↓ 2 lines elided ↑ open up ↑ 
 493  473  void smb_server_inc_trees(smb_server_t *);
 494  474  void smb_server_dec_trees(smb_server_t *);
 495  475  void smb_server_inc_files(smb_server_t *);
 496  476  void smb_server_dec_files(smb_server_t *);
 497  477  void smb_server_inc_pipes(smb_server_t *);
 498  478  void smb_server_dec_pipes(smb_server_t *);
 499  479  void smb_server_add_rxb(smb_server_t *, int64_t);
 500  480  void smb_server_add_txb(smb_server_t *, int64_t);
 501  481  void smb_server_inc_req(smb_server_t *);
 502  482  
      483 +void smb_server_post_session(smb_session_t *);
      484 +
 503  485  smb_event_t *smb_event_create(smb_server_t *, int);
 504  486  void smb_event_destroy(smb_event_t *);
 505  487  uint32_t smb_event_txid(smb_event_t *);
 506  488  int smb_event_wait(smb_event_t *);
 507  489  void smb_event_notify(smb_server_t *, uint32_t);
 508  490  
 509  491  /*
 510  492   * SMB node functions (file smb_node.c)
 511  493   */
 512  494  void smb_node_init(void);
↓ open down ↓ 28 lines elided ↑ open up ↑ 
 541  523  boolean_t smb_node_is_dfslink(smb_node_t *);
 542  524  boolean_t smb_node_is_reparse(smb_node_t *);
 543  525  boolean_t smb_node_is_vfsroot(smb_node_t *);
 544  526  boolean_t smb_node_is_system(smb_node_t *);
 545  527  
 546  528  uint32_t smb_node_open_check(smb_node_t *, uint32_t, uint32_t);
 547  529  DWORD smb_node_rename_check(smb_node_t *);
 548  530  DWORD smb_node_delete_check(smb_node_t *);
 549  531  boolean_t smb_node_share_check(smb_node_t *);
 550  532  
 551      -void smb_node_fcn_subscribe(smb_node_t *, smb_request_t *);
 552      -void smb_node_fcn_unsubscribe(smb_node_t *, smb_request_t *);
      533 +void smb_node_fcn_subscribe(smb_node_t *);
      534 +void smb_node_fcn_unsubscribe(smb_node_t *);
 553  535  void smb_node_notify_change(smb_node_t *, uint_t, const char *);
 554      -void smb_node_notify_parents(smb_node_t *);
      536 +
 555  537  int smb_node_getattr(smb_request_t *, smb_node_t *, cred_t *,
 556  538      smb_ofile_t *, smb_attr_t *);
 557  539  int smb_node_setattr(smb_request_t *, smb_node_t *, cred_t *,
 558  540      smb_ofile_t *, smb_attr_t *);
 559  541  uint32_t smb_node_set_delete_on_close(smb_node_t *, cred_t *, uint32_t);
 560  542  void smb_node_reset_delete_on_close(smb_node_t *);
      543 +void smb_node_delete_on_close(smb_node_t *);
 561  544  boolean_t smb_node_file_is_readonly(smb_node_t *);
 562  545  int smb_node_getpath(smb_node_t *, vnode_t *, char *, uint32_t);
      546 +void smb_node_getpath_nofail(smb_node_t *, vnode_t *, char *, uint32_t);
 563  547  int smb_node_getmntpath(smb_node_t *, char *, uint32_t);
 564  548  int smb_node_getshrpath(smb_node_t *, smb_tree_t *, char *, uint32_t);
 565  549  
 566  550  /*
 567  551   * Pathname functions
 568  552   */
 569  553  
 570  554  int smb_pathname_reduce(smb_request_t *, cred_t *,
 571  555      const char *, smb_node_t *, smb_node_t *, smb_node_t **, char *);
 572  556  
 573  557  int smb_pathname(smb_request_t *, char *, int, smb_node_t *,
 574      -    smb_node_t *, smb_node_t **, smb_node_t **, cred_t *);
      558 +    smb_node_t *, smb_node_t **, smb_node_t **, cred_t *, pathname_t *);
 575  559  
 576  560  /*
 577      - * smb_vfs functions
      561 + * smb_notify.c
 578  562   */
      563 +uint32_t smb_notify_act1(smb_request_t *, uint32_t, uint32_t);
      564 +uint32_t smb_notify_act2(smb_request_t *);
      565 +uint32_t smb_notify_act3(smb_request_t *);
      566 +void smb_notify_ofile(smb_ofile_t *, uint_t, const char *);
      567 +void smb_nt_transact_notify_finish(void *);
      568 +void smb2_change_notify_finish(void *);
 579  569  
 580      -int smb_vfs_hold(smb_export_t *, vfs_t *);
 581      -void smb_vfs_rele(smb_export_t *, vfs_t *);
 582      -void smb_vfs_rele_all(smb_export_t *);
 583      -
 584      -/* NOTIFY CHANGE */
 585      -
 586      -uint32_t smb_notify_common(smb_request_t *, mbuf_chain_t *, uint32_t);
 587      -void smb_notify_event(smb_node_t *, uint_t, const char *);
 588      -void smb_notify_file_closed(smb_ofile_t *);
 589      -
 590  570  int smb_fem_fcn_install(smb_node_t *);
 591  571  void smb_fem_fcn_uninstall(smb_node_t *);
 592  572  int smb_fem_oplock_install(smb_node_t *);
 593  573  void smb_fem_oplock_uninstall(smb_node_t *);
 594  574  
 595  575  /* FEM */
 596  576  
 597  577  int smb_fem_init(void);
 598  578  void smb_fem_fini(void);
 599  579  
 600  580  int smb_try_grow(smb_request_t *sr, int64_t new_size);
 601  581  
 602  582  unsigned short smb_worker_getnum();
 603  583  
 604  584  /* SMB signing routines smb_signing.c */
 605      -int smb_sign_begin(smb_request_t *, smb_token_t *);
      585 +void smb_sign_begin(smb_request_t *, smb_token_t *);
 606  586  int smb_sign_check_request(smb_request_t *);
 607  587  int smb_sign_check_secondary(smb_request_t *, unsigned int);
 608  588  void smb_sign_reply(smb_request_t *, mbuf_chain_t *);
 609  589  /* SMB2, but here because it's called from common code. */
 610      -int smb2_sign_begin(smb_request_t *, smb_token_t *);
      590 +void smb2_sign_begin(smb_request_t *, smb_token_t *);
      591 +void smb3_encrypt_begin(smb_request_t *, smb_token_t *);
      592 +void smb3_encrypt_fini(smb_session_t *);
 611  593  
 612  594  boolean_t smb_sattr_check(uint16_t, uint16_t);
 613  595  
 614  596  void smb_request_cancel(smb_request_t *);
 615  597  void smb_request_wait(smb_request_t *);
 616  598  
 617  599  /*
 618  600   * authentication support (smb_authenticate.c)
 619  601   */
 620  602  int smb_authenticate_ext(smb_request_t *);
 621  603  int smb_authenticate_old(smb_request_t *);
 622      -void smb_authsock_close(smb_user_t *);
      604 +void smb_authsock_close(smb_user_t *, ksocket_t);
 623  605  
 624  606  /*
 625  607   * session functions (file smb_session.c)
 626  608   */
 627  609  smb_session_t *smb_session_create(ksocket_t, uint16_t, smb_server_t *, int);
      610 +smb_session_t *smb_server_find_session_byptr(smb_server_t *, void *);
      611 +
      612 +void smb_session_hold(smb_session_t *);
      613 +void smb_session_release(smb_session_t *);
 628  614  void smb_session_receiver(smb_session_t *);
 629  615  void smb_session_disconnect(smb_session_t *);
 630      -void smb_session_timers(smb_llist_t *);
      616 +void smb_session_timers(smb_server_t *);
 631  617  void smb_session_delete(smb_session_t *session);
 632  618  void smb_session_cancel_requests(smb_session_t *, smb_tree_t *,
 633  619      smb_request_t *);
 634  620  void smb_session_config(smb_session_t *session);
 635  621  void smb_session_disconnect_from_share(smb_llist_t *, char *);
 636  622  smb_user_t *smb_session_dup_user(smb_session_t *, char *, char *);
      623 +smb_user_t *smb_session_lookup_ssnid(smb_session_t *, uint64_t);
 637  624  smb_user_t *smb_session_lookup_uid(smb_session_t *, uint16_t);
 638      -smb_user_t *smb_session_lookup_uid_st(smb_session_t *session,
 639      -    uint16_t uid, smb_user_state_t st);
 640      -void smb_session_post_user(smb_session_t *, smb_user_t *);
 641      -void smb_session_post_tree(smb_session_t *, smb_tree_t *);
      625 +smb_user_t *smb_session_lookup_uid_st(smb_session_t *,
      626 +    uint64_t, uint16_t, smb_user_state_t);
 642  627  smb_tree_t *smb_session_lookup_tree(smb_session_t *, uint16_t);
 643  628  smb_tree_t *smb_session_lookup_share(smb_session_t *, const char *,
 644  629      smb_tree_t *);
 645  630  smb_tree_t *smb_session_lookup_volume(smb_session_t *, const char *,
 646  631      smb_tree_t *);
 647  632  void smb_session_close_pid(smb_session_t *, uint32_t);
 648  633  void smb_session_disconnect_owned_trees(smb_session_t *, smb_user_t *);
 649      -void smb_session_disconnect_trees(smb_session_t *);
 650  634  void smb_session_disconnect_share(smb_session_t *, const char *);
      635 +void smb_session_logoff(smb_session_t *);
 651  636  void smb_session_getclient(smb_session_t *, char *, size_t);
 652  637  boolean_t smb_session_isclient(smb_session_t *, const char *);
 653  638  void smb_session_correct_keep_alive_values(smb_llist_t *, uint32_t);
 654      -void smb_session_oplock_break(smb_request_t *, uint8_t);
 655  639  int smb_session_send(smb_session_t *, uint8_t type, mbuf_chain_t *);
 656  640  int smb_session_xprt_gethdr(smb_session_t *, smb_xprt_t *);
 657  641  boolean_t smb_session_oplocks_enable(smb_session_t *);
 658  642  boolean_t smb_session_levelII_oplocks(smb_session_t *);
 659  643  
 660  644  #define SMB_SESSION_GET_ID(s)   ((s)->s_kid)
 661  645  
 662  646  smb_request_t *smb_request_alloc(smb_session_t *, int);
 663  647  void smb_request_free(smb_request_t *);
 664  648  
 665  649  /*
 666  650   * ofile functions (file smb_ofile.c)
 667  651   */
 668  652  smb_ofile_t *smb_ofile_lookup_by_fid(smb_request_t *, uint16_t);
 669  653  smb_ofile_t *smb_ofile_lookup_by_uniqid(smb_tree_t *, uint32_t);
      654 +smb_ofile_t *smb_ofile_lookup_by_persistid(smb_request_t *, uint64_t);
 670  655  boolean_t smb_ofile_disallow_fclose(smb_ofile_t *);
 671      -smb_ofile_t *smb_ofile_open(smb_request_t *, smb_node_t *,
 672      -    smb_arg_open_t *, uint16_t, uint32_t, smb_error_t *);
      656 +smb_ofile_t *smb_ofile_alloc(smb_request_t *, smb_arg_open_t *, smb_node_t *,
      657 +    uint16_t, uint16_t);
      658 +void smb_ofile_open(smb_request_t *, smb_arg_open_t *, smb_ofile_t *);
 673  659  void smb_ofile_close(smb_ofile_t *, int32_t);
 674      -void smb_ofile_delete(void *);
      660 +void smb_ofile_free(smb_ofile_t *);
 675  661  uint32_t smb_ofile_access(smb_ofile_t *, cred_t *, uint32_t);
 676  662  int smb_ofile_seek(smb_ofile_t *, ushort_t, int32_t, uint32_t *);
 677  663  void smb_ofile_flush(smb_request_t *, smb_ofile_t *);
 678  664  boolean_t smb_ofile_hold(smb_ofile_t *);
      665 +boolean_t smb_ofile_hold_olbrk(smb_ofile_t *);
 679  666  void smb_ofile_release(smb_ofile_t *);
 680      -void smb_ofile_request_complete(smb_ofile_t *);
 681      -void smb_ofile_close_all(smb_tree_t *);
 682      -void smb_ofile_close_all_by_pid(smb_tree_t *, uint16_t);
      667 +void smb_ofile_close_all(smb_tree_t *, uint32_t);
 683  668  void smb_ofile_set_flags(smb_ofile_t *, uint32_t);
 684  669  boolean_t smb_ofile_is_open(smb_ofile_t *);
 685  670  int smb_ofile_enum(smb_ofile_t *, smb_svcenum_t *);
 686  671  uint32_t smb_ofile_open_check(smb_ofile_t *, uint32_t, uint32_t);
 687  672  uint32_t smb_ofile_rename_check(smb_ofile_t *);
 688  673  uint32_t smb_ofile_delete_check(smb_ofile_t *);
 689  674  boolean_t smb_ofile_share_check(smb_ofile_t *);
 690  675  cred_t *smb_ofile_getcred(smb_ofile_t *);
 691      -void smb_ofile_set_delete_on_close(smb_ofile_t *);
      676 +void smb_ofile_set_delete_on_close(smb_request_t *, smb_ofile_t *);
 692  677  void smb_delayed_write_timer(smb_llist_t *);
 693  678  void smb_ofile_set_quota_resume(smb_ofile_t *, char *);
 694  679  void smb_ofile_get_quota_resume(smb_ofile_t *, char *, int);
      680 +void smb_ofile_del_persistid(smb_ofile_t *);
      681 +void smb_ofile_set_persistid_dh(smb_ofile_t *);
      682 +void smb_ofile_set_persistid_ph(smb_ofile_t *);
      683 +int smb_ofile_insert_persistid(smb_ofile_t *, uint64_t);
 695  684  
 696  685  #define SMB_OFILE_GET_SESSION(of)       ((of)->f_session)
 697  686  #define SMB_OFILE_GET_TREE(of)          ((of)->f_tree)
 698  687  #define SMB_OFILE_GET_FID(of)           ((of)->f_fid)
 699  688  #define SMB_OFILE_GET_NODE(of)          ((of)->f_node)
 700  689  
 701  690  #define smb_ofile_granted_access(_of_)  ((_of_)->f_granted_access)
 702  691  
 703  692  /*
 704  693   * odir functions (file smb_odir.c)
 705  694   */
 706  695  uint32_t smb_odir_openpath(smb_request_t *, char *, uint16_t, uint32_t,
 707  696      smb_odir_t **);
 708  697  uint32_t smb_odir_openfh(smb_request_t *, const char *, uint16_t,
 709  698      smb_odir_t **);
 710  699  uint32_t smb_odir_openat(smb_request_t *, smb_node_t *, smb_odir_t **);
 711  700  void smb_odir_reopen(smb_odir_t *, const char *, uint16_t);
 712  701  void smb_odir_close(smb_odir_t *);
 713  702  boolean_t smb_odir_hold(smb_odir_t *);
 714  703  void smb_odir_release(smb_odir_t *);
 715      -void smb_odir_delete(void *);
 716  704  
 717  705  int smb_odir_read(smb_request_t *, smb_odir_t *,
 718  706      smb_odirent_t *, boolean_t *);
 719  707  int smb_odir_read_fileinfo(smb_request_t *, smb_odir_t *,
 720  708      smb_fileinfo_t *, uint16_t *);
 721  709  int smb_odir_read_streaminfo(smb_request_t *, smb_odir_t *,
 722  710      smb_streaminfo_t *, boolean_t *);
 723  711  
 724  712  void smb_odir_save_cookie(smb_odir_t *, int, uint32_t cookie);
 725  713  void smb_odir_save_fname(smb_odir_t *, uint32_t, const char *);
 726  714  
 727  715  void smb_odir_resume_at(smb_odir_t *, smb_odir_resume_t *);
 728  716  
 729  717  /*
 730  718   * SMB user functions (file smb_user.c)
 731  719   */
 732  720  smb_user_t *smb_user_new(smb_session_t *);
 733  721  int smb_user_logon(smb_user_t *, cred_t *,
 734  722      char *, char *, uint32_t, uint32_t, uint32_t);
 735      -smb_user_t *smb_user_dup(smb_user_t *);
 736  723  void smb_user_logoff(smb_user_t *);
 737      -void smb_user_delete(void *);
      724 +void smb_user_auth_tmo(void *);
      725 +
 738  726  boolean_t smb_user_is_admin(smb_user_t *);
 739  727  boolean_t smb_user_namecmp(smb_user_t *, const char *);
 740  728  int smb_user_enum(smb_user_t *, smb_svcenum_t *);
 741  729  boolean_t smb_user_hold(smb_user_t *);
 742  730  void smb_user_hold_internal(smb_user_t *);
 743  731  void smb_user_release(smb_user_t *);
 744  732  cred_t *smb_user_getcred(smb_user_t *);
 745  733  cred_t *smb_user_getprivcred(smb_user_t *);
 746  734  void smb_user_netinfo_init(smb_user_t *, smb_netuserinfo_t *);
 747  735  void smb_user_netinfo_fini(smb_netuserinfo_t *);
 748  736  int smb_user_netinfo_encode(smb_user_t *, uint8_t *, size_t, uint32_t *);
 749  737  smb_token_t *smb_get_token(smb_session_t *, smb_logon_t *);
 750      -cred_t *smb_cred_create(smb_token_t *);
      738 +cred_t *smb_cred_create(smb_token_t *, smb_session_t *);
      739 +cred_t *smb_kcred_create(void);
 751  740  void smb_user_setcred(smb_user_t *, cred_t *, uint32_t);
      741 +boolean_t smb_is_same_user(cred_t *, cred_t *);
 752  742  
 753  743  /*
 754  744   * SMB tree functions (file smb_tree.c)
 755  745   */
 756  746  uint32_t smb_tree_connect(smb_request_t *);
      747 +uint32_t smb_tree_connect_disk(smb_request_t *, smb_arg_tcon_t *);
 757  748  void smb_tree_disconnect(smb_tree_t *, boolean_t);
 758      -void smb_tree_dealloc(void *);
 759      -void smb_tree_post_ofile(smb_tree_t *, smb_ofile_t *);
 760      -void smb_tree_post_odir(smb_tree_t *, smb_odir_t *);
 761  749  void smb_tree_close_pid(smb_tree_t *, uint32_t);
 762  750  boolean_t smb_tree_has_feature(smb_tree_t *, uint_t);
 763  751  int smb_tree_enum(smb_tree_t *, smb_svcenum_t *);
 764  752  int smb_tree_fclose(smb_tree_t *, uint32_t);
 765  753  boolean_t smb_tree_hold(smb_tree_t *);
 766  754  void smb_tree_hold_internal(smb_tree_t *);
 767  755  void smb_tree_release(smb_tree_t *);
 768  756  smb_odir_t *smb_tree_lookup_odir(smb_request_t *, uint16_t);
 769  757  boolean_t smb_tree_is_connected(smb_tree_t *);
 770      -#define SMB_TREE_GET_TID(tree)          ((tree)->t_tid)
      758 +smb_tree_t *smb_tree_alloc(smb_request_t *, const smb_kshare_t *,
      759 +    smb_node_t *, uint32_t, uint32_t);
 771  760  
 772  761  smb_xa_t *smb_xa_create(smb_session_t *session, smb_request_t *sr,
 773  762      uint32_t total_parameter_count, uint32_t total_data_count,
 774  763      uint32_t max_parameter_count, uint32_t max_data_count,
 775  764      uint32_t max_setup_count, uint32_t setup_word_count);
 776  765  void smb_xa_delete(smb_xa_t *xa);
 777  766  smb_xa_t *smb_xa_hold(smb_xa_t *xa);
 778  767  void smb_xa_rele(smb_session_t *session, smb_xa_t *xa);
 779  768  int smb_xa_open(smb_xa_t *xa);
 780  769  void smb_xa_close(smb_xa_t *xa);
 781  770  int smb_xa_complete(smb_xa_t *xa);
 782  771  smb_xa_t *smb_xa_find(smb_session_t *session, uint32_t pid, uint16_t mid);
 783  772  
 784  773  struct mbuf *smb_mbuf_get(uchar_t *buf, int nbytes);
 785  774  struct mbuf *smb_mbuf_allocate(struct uio *uio);
 786  775  void smb_mbuf_trim(struct mbuf *mhead, int nbytes);
 787  776  
 788      -void smb_check_status(void);
 789      -int smb_handle_write_raw(smb_session_t *session, smb_request_t *sr);
 790      -
 791  777  int32_t smb_time_gmt_to_local(smb_request_t *, int32_t);
 792  778  int32_t smb_time_local_to_gmt(smb_request_t *, int32_t);
 793  779  int32_t smb_time_dos_to_unix(int16_t, int16_t);
 794  780  void smb_time_unix_to_dos(int32_t, int16_t *, int16_t *);
 795  781  void smb_time_nt_to_unix(uint64_t nt_time, timestruc_t *unix_time);
 796  782  uint64_t smb_time_unix_to_nt(timestruc_t *);
 797  783  
 798  784  int netbios_name_isvalid(char *in, char *out);
 799  785  
 800  786  int uioxfer(struct uio *src_uio, struct uio *dst_uio, int n);
↓ open down ↓ 6 lines elided ↑ open up ↑ 
 807  793  int     smb_idpool_alloc(smb_idpool_t *pool, uint16_t *id);
 808  794  void    smb_idpool_free(smb_idpool_t *pool, uint16_t id);
 809  795  
 810  796  /*
 811  797   * SMB locked list function prototypes
 812  798   */
 813  799  void    smb_llist_init(void);
 814  800  void    smb_llist_fini(void);
 815  801  void    smb_llist_constructor(smb_llist_t *, size_t, size_t);
 816  802  void    smb_llist_destructor(smb_llist_t *);
      803 +void    smb_llist_enter(smb_llist_t *ll, krw_t);
 817  804  void    smb_llist_exit(smb_llist_t *);
 818  805  void    smb_llist_post(smb_llist_t *, void *, smb_dtorproc_t);
 819  806  void    smb_llist_flush(smb_llist_t *);
 820  807  void    smb_llist_insert_head(smb_llist_t *ll, void *obj);
 821  808  void    smb_llist_insert_tail(smb_llist_t *ll, void *obj);
 822  809  void    smb_llist_remove(smb_llist_t *ll, void *obj);
 823  810  int     smb_llist_upgrade(smb_llist_t *ll);
 824  811  uint32_t smb_llist_get_count(smb_llist_t *ll);
 825      -#define smb_llist_enter(ll, mode)       rw_enter(&(ll)->ll_lock, mode)
 826  812  #define smb_llist_head(ll)              list_head(&(ll)->ll_list)
 827  813  #define smb_llist_next(ll, obj)         list_next(&(ll)->ll_list, obj)
 828  814  int     smb_account_connected(smb_user_t *user);
 829  815  
 830  816  /*
 831  817   * SMB Synchronized list function prototypes
 832  818   */
 833  819  void    smb_slist_constructor(smb_slist_t *, size_t, size_t);
 834  820  void    smb_slist_destructor(smb_slist_t *);
 835  821  void    smb_slist_insert_head(smb_slist_t *sl, void *obj);
↓ open down ↓ 2 lines elided ↑ open up ↑ 
 838  824  void    smb_slist_wait_for_empty(smb_slist_t *sl);
 839  825  void    smb_slist_exit(smb_slist_t *sl);
 840  826  uint32_t smb_slist_move_tail(list_t *lst, smb_slist_t *sl);
 841  827  void    smb_slist_obj_move(smb_slist_t *dst, smb_slist_t *src, void *obj);
 842  828  #define smb_slist_enter(sl)             mutex_enter(&(sl)->sl_mutex)
 843  829  #define smb_slist_head(sl)              list_head(&(sl)->sl_list)
 844  830  #define smb_slist_next(sl, obj)         list_next(&(sl)->sl_list, obj)
 845  831  
 846  832  void    smb_rwx_init(smb_rwx_t *rwx);
 847  833  void    smb_rwx_destroy(smb_rwx_t *rwx);
 848      -#define smb_rwx_rwenter(rwx, mode)      rw_enter(&(rwx)->rwx_lock, mode)
      834 +void    smb_rwx_rwenter(smb_rwx_t *rwx, krw_t);
 849  835  void    smb_rwx_rwexit(smb_rwx_t *rwx);
 850      -int     smb_rwx_rwwait(smb_rwx_t *rwx, clock_t timeout);
 851      -#define smb_rwx_xenter(rwx)             mutex_enter(&(rwx)->rwx_mutex)
 852      -#define smb_rwx_xexit(rwx)              mutex_exit(&(rwx)->rwx_mutex)
 853      -krw_t   smb_rwx_rwupgrade(smb_rwx_t *rwx);
 854      -void    smb_rwx_rwdowngrade(smb_rwx_t *rwx, krw_t mode);
      836 +int     smb_rwx_cvwait(smb_rwx_t *rwx, clock_t timeout);
      837 +void    smb_rwx_cvbcast(smb_rwx_t *rwx);
 855  838  
 856  839  void    smb_thread_init(smb_thread_t *, char *, smb_thread_ep_t,
 857  840                  void *, pri_t);
 858  841  void    smb_thread_destroy(smb_thread_t *);
 859  842  int     smb_thread_start(smb_thread_t *);
 860  843  void    smb_thread_stop(smb_thread_t *);
 861  844  void    smb_thread_signal(smb_thread_t *);
 862  845  boolean_t smb_thread_continue(smb_thread_t *);
 863  846  boolean_t smb_thread_continue_nowait(smb_thread_t *);
 864  847  boolean_t smb_thread_continue_timedwait(smb_thread_t *, int /* seconds */);
↓ open down ↓ 11 lines elided ↑ open up ↑ 
 876  859  acl_t *smb_fsacl_merge(acl_t *, acl_t *);
 877  860  void smb_fsacl_split(acl_t *, acl_t **, acl_t **, int);
 878  861  acl_t *smb_fsacl_from_vsa(vsecattr_t *, acl_type_t);
 879  862  int smb_fsacl_to_vsa(acl_t *, vsecattr_t *, int *);
 880  863  
 881  864  boolean_t smb_ace_is_generic(int);
 882  865  boolean_t smb_ace_is_access(int);
 883  866  boolean_t smb_ace_is_audit(int);
 884  867  
 885  868  uint32_t smb_vss_enum_snapshots(smb_request_t *, smb_fsctl_t *);
 886      -int smb_vss_lookup_nodes(smb_request_t *, smb_node_t *, smb_node_t *,
 887      -    char *, smb_node_t **, smb_node_t **);
      869 +int smb_vss_lookup_nodes(smb_request_t *, smb_node_t *, smb_node_t **, char *);
 888  870  vnode_t *smb_lookuppathvptovp(smb_request_t *, char *, vnode_t *, vnode_t *);
      871 +int smb_vss_extract_gmttoken(char *, char *);
 889  872  
 890  873  void smb_panic(char *, const char *, int);
 891  874  #pragma does_not_return(smb_panic)
 892  875  #define SMB_PANIC()     smb_panic(__FILE__, __func__, __LINE__)
 893  876  
 894  877  void smb_latency_init(smb_latency_t *);
 895  878  void smb_latency_destroy(smb_latency_t *);
 896  879  void smb_latency_add_sample(smb_latency_t *, hrtime_t);
 897  880  void smb_srqueue_init(smb_srqueue_t *);
 898  881  void smb_srqueue_destroy(smb_srqueue_t *);
↓ open down ↓ 53 lines elided ↑ open up ↑ 
 952  935  void smb_avl_iterinit(smb_avl_t *, smb_avl_cursor_t *);
 953  936  void *smb_avl_iterate(smb_avl_t *, smb_avl_cursor_t *);
 954  937  
 955  938  void smb_threshold_init(smb_cmd_threshold_t *,
 956  939      char *, uint_t, uint_t);
 957  940  void smb_threshold_fini(smb_cmd_threshold_t *);
 958  941  int smb_threshold_enter(smb_cmd_threshold_t *);
 959  942  void smb_threshold_exit(smb_cmd_threshold_t *);
 960  943  void smb_threshold_wake_all(smb_cmd_threshold_t *);
 961  944  
      945 +/* SMB hash function prototypes */
      946 +smb_hash_t *smb_hash_create(size_t, size_t, uint32_t);
      947 +void smb_hash_destroy(smb_hash_t *);
      948 +uint_t smb_hash_uint64(smb_hash_t *, uint64_t);
      949 +
      950 +/* SMB auditing helper functions */
      951 +boolean_t smb_audit_init(smb_request_t *);
      952 +void smb_audit_fini(smb_request_t *, uint32_t, smb_node_t *, boolean_t);
      953 +boolean_t smb_audit_rename_init(smb_request_t *);
      954 +void smb_audit_rename_fini(smb_request_t *, char *, smb_node_t *, char *,
      955 +    boolean_t, boolean_t);
      956 +void smb_audit_save(void);
      957 +void smb_audit_load(void);
      958 +vnode_t *smb_audit_rootvp(smb_request_t *);
      959 +
 962  960  #ifdef  __cplusplus
 963  961  }
 964  962  #endif
 965  963  
 966  964  #endif /* _SMB_KPROTO_H_ */
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX