xref: /titanic_51/usr/src/uts/common/smbsrv/smb_kproto.h (revision c869993e79c1eafbec61a56bf6cea848fe754c71)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 /*
22  * Copyright 2008 Sun Microsystems, Inc.  All rights reserved.
23  * Use is subject to license terms.
24  */
25 
26 /*
27  * Function prototypes for the SMB module.
28  */
29 
30 #ifndef _SMB_KPROTO_H_
31 #define	_SMB_KPROTO_H_
32 
33 #pragma ident	"%Z%%M%	%I%	%E% SMI"
34 
35 #ifdef	__cplusplus
36 extern "C" {
37 #endif
38 
39 #include <sys/systm.h>
40 #include <sys/socket.h>
41 #include <sys/strsubr.h>
42 #include <sys/socketvar.h>
43 #include <sys/cred.h>
44 #include <smbsrv/smb_vops.h>
45 #include <smbsrv/smb_xdr.h>
46 #include <smbsrv/smb_token.h>
47 #include <smbsrv/smbvar.h>
48 
49 /*
50  * Definitions that should be elsewhere...
51  */
52 struct mbuf	*m_free(struct mbuf *);
53 void		m_freem(struct mbuf *);
54 
55 int		fd_dealloc(int);
56 
57 off_t		lseek(int fildes, off_t offset, int whence);
58 
59 int		arpioctl(int cmd, void *data);
60 /* Why? uint32_t	inet_addr(char *str); */
61 int		microtime(timestruc_t *tvp);
62 int		clock_get_uptime(void);
63 
64 /*
65  * SMB Service init/shutdown functions
66  */
67 int smb_service_init(void);
68 void smb_service_fini(void);
69 int smb_service_open(struct smb_info *si);
70 void smb_service_close(struct smb_info *si);
71 int smb_service_connect(struct smb_info *si);
72 void smb_service_disconnect(struct smb_info *si);
73 int smb_service_start_threads(struct smb_info *si);
74 void smb_service_stop_threads(struct smb_info *si);
75 
76 /*
77  * Logging functions
78  */
79 void smb_log_flush(void);
80 void smb_correct_keep_alive_values(uint32_t new_keep_alive);
81 void smb_close_all_connections(void);
82 int smb_set_file_size(struct smb_request *sr);
83 int smb_session_send(smb_session_t *, uint8_t type, struct mbuf_chain *);
84 int smb_session_xprt_gethdr(smb_session_t *, smb_xprt_t *);
85 
86 int smb_net_id(uint32_t);
87 uint32_t smb_gmt_to_local_time(uint32_t);
88 uint32_t smb_local_time_to_gmt(uint32_t);
89 
90 void smb_process_file_notify_change_queue(struct smb_ofile *of);
91 
92 void smb_oplock_init(void);
93 
94 DWORD smb_acquire_oplock(struct smb_request *sr,
95     struct smb_ofile *file,
96     unsigned int level_requested,
97     unsigned int *level_granted);
98 
99 DWORD smb_break_oplock(struct smb_request *sr, struct smb_node *node);
100 void smb_release_oplock(struct smb_ofile *file, int reason);
101 
102 uint32_t smb_unlock_range(struct smb_request *, struct smb_node *,
103     uint64_t, uint64_t);
104 uint32_t smb_lock_range(struct smb_request *, struct smb_ofile *,
105     uint64_t, uint64_t, uint32_t, uint32_t);
106 void smb_lock_range_error(smb_request_t *, uint32_t);
107 
108 DWORD smb_range_check(smb_request_t *, cred_t *, smb_node_t *,
109     uint64_t, uint64_t, boolean_t);
110 
111 int smb_mangle_name(ino64_t fileid, char *name, char *shortname,
112     char *name83, int force);
113 int smb_unmangle_name(struct smb_request *sr, cred_t *cred,
114     smb_node_t *dir_node, char *name, char *real_name, int realname_size,
115     char *shortname, char *name83, int od);
116 int smb_maybe_mangled_name(char *name);
117 int smb_maybe_mangled_path(const char *path, size_t pathlen);
118 int smb_needs_mangle(char *name, char **dot_pos);
119 
120 void smb_set_stability(int mode);
121 void smb_commit_required(int state);
122 
123 
124 void smbsr_cleanup(struct smb_request *sr);
125 
126 int smbsr_connect_tree(struct smb_request *);
127 
128 int		smb_convert_unicode_wildcards(char *);
129 int	smb_ascii_or_unicode_strlen(struct smb_request *, char *);
130 int	smb_ascii_or_unicode_strlen_null(struct smb_request *, char *);
131 int	smb_ascii_or_unicode_null_len(struct smb_request *);
132 
133 int	smb_search(struct smb_request *);
134 void smb_rdir_close(struct smb_request *);
135 int	smb_rdir_open(struct smb_request *, char *, unsigned short);
136 int smb_rdir_next(smb_request_t *sr, smb_node_t **rnode,
137     smb_odir_context_t *pc);
138 
139 DWORD smb_open_subr(struct smb_request *);
140 DWORD smb_validate_object_name(char *path, unsigned int ftype);
141 
142 uint32_t smb_omode_to_amask(uint32_t desired_access);
143 
144 void	sshow_distribution_info(char *);
145 
146 int	smb_dispatch_request(struct smb_request *);
147 void	smbsr_disconnect_file(smb_request_t *sr);
148 void	smbsr_disconnect_dir(smb_request_t *sr);
149 void	smbsr_check_result(struct smb_request *, int, int);
150 void	smbsr_decode_error(struct smb_request *);
151 void	smbsr_encode_error(struct smb_request *);
152 void	smbsr_encode_empty_result(struct smb_request *sr);
153 
154 int	smbsr_decode_vwv(struct smb_request *sr, char *fmt, ...);
155 int	smbsr_decode_data(struct smb_request *sr, char *fmt, ...);
156 void	smbsr_encode_result(struct smb_request *, int, int, char *, ...);
157 smb_xa_t *smbsr_lookup_xa(smb_request_t *sr);
158 void	smbsr_send_reply(struct smb_request *);
159 
160 void	smbsr_map_errno(int, smb_error_t *);
161 void	smbsr_set_error(smb_request_t *, smb_error_t *);
162 void	smbsr_errno(struct smb_request *, int);
163 void	smbsr_warn(struct smb_request *, DWORD, uint16_t, uint16_t);
164 void	smbsr_error(struct smb_request *, DWORD, uint16_t, uint16_t);
165 
166 int	smb_mbc_encode(struct mbuf_chain *mbc, char *fmt, va_list ap);
167 int	smb_mbc_decode(struct mbuf_chain *mbc, char *fmt, va_list ap);
168 
169 int	clock_get_milli_uptime(void);
170 int	dosfs_dos_to_ux_time(int, int);
171 int	dosfs_ux_to_dos_time(int, short int *, short int *);
172 
173 int	smb_decode_mbc(struct  mbuf_chain *mbc, char *fmt, ...);
174 int	smb_decode_buf(unsigned char *buf, int n_buf, char *fmt, ...);
175 int	smb_encode_mbc(struct mbuf_chain *mbc, char *fmt, ...);
176 int	smb_encode_buf(unsigned char *buf, int n_buf, char *fmt, ...);
177 int	smb_peek_mbc(struct mbuf_chain *buf, int offset, char *fmt, ...);
178 int	smb_poke_mbc(struct mbuf_chain *buf, int offset, char *fmt, ...);
179 
180 void	smbsr_encode_header(struct smb_request *sr, int wct,
181 		    int bcc, char *fmt, ...);
182 
183 int	smb_xlate_dialect_str_to_cd(char *);
184 char	*smb_xlate_com_cd_to_str(int);
185 char	*smb_xlate_dialect_cd_to_str(int);
186 
187 void	smb_od_destruct(struct smb_session *, struct smb_odir *);
188 int	smbd_fs_query(struct smb_request *, struct smb_fqi *, int);
189 int smb_component_match(struct smb_request *sr, ino64_t fileid,
190     struct smb_odir *od, smb_odir_context_t *pc);
191 
192 int smb_lock_range_access(struct smb_request *, struct smb_node *,
193     uint64_t, uint64_t, boolean_t);
194 
195 uint32_t smb_decode_sd(struct smb_xa *, smb_sd_t *);
196 
197 /*
198  * Socket functions
199  */
200 struct sonode *smb_socreate(int domain, int type, int protocol);
201 void smb_soshutdown(struct sonode *so);
202 void smb_sodestroy(struct sonode *so);
203 int smb_sosend(struct sonode *so, void *msg, size_t len);
204 int smb_sorecv(struct sonode *so, void *msg, size_t len);
205 int smb_iov_sosend(struct sonode *so, iovec_t *iop, int iovlen,
206     size_t total_len);
207 int smb_iov_sorecv(struct sonode *so, iovec_t *iop, int iovlen,
208     size_t total_len);
209 
210 /*
211  * SMB RPC interface
212  */
213 int smb_rpc_open(struct smb_request *sr);
214 void smb_rpc_close(struct smb_ofile *of);
215 int smb_rpc_transact(struct smb_request *sr, struct uio *uio);
216 int smb_rpc_read(struct smb_request *sr, struct uio *uio);
217 int smb_rpc_write(struct smb_request *sr, struct uio *uio);
218 
219 /*
220  * SMB node functions (file smb_node.c)
221  */
222 struct smb_node *smb_node_lookup(struct smb_request *sr, struct open_param *op,
223     cred_t *cr, vnode_t *vp, char *od_name, smb_node_t *dir_snode,
224     smb_node_t *unnamed_node, smb_attr_t *attr);
225 struct smb_node *smb_stream_node_lookup(struct smb_request *sr, cred_t *cr,
226     smb_node_t *fnode, vnode_t *xattrdirvp, vnode_t *vp, char *stream_name,
227     smb_attr_t *ret_attr);
228 void smb_node_ref(smb_node_t *node);
229 void smb_node_release(smb_node_t *node);
230 int smb_node_assert(smb_node_t *node, const char *file, int line);
231 int smb_node_rename(smb_node_t *from_dir_snode, smb_node_t *ret_snode,
232     smb_node_t *to_dir_snode, char *to_name);
233 int smb_node_root_init();
234 void smb_node_root_fini();
235 void smb_node_add_lock(smb_node_t *node, smb_lock_t *lock);
236 void smb_node_destroy_lock(smb_node_t *node, smb_lock_t *lock);
237 void smb_node_destroy_lock_by_ofile(smb_node_t *node, smb_ofile_t *file);
238 void smb_node_start_crit(smb_node_t *node, krw_t mode);
239 void smb_node_end_crit(smb_node_t *node);
240 int smb_node_in_crit(smb_node_t *node);
241 
242 uint32_t smb_node_open_check(smb_node_t *, cred_t *,
243     uint32_t, uint32_t);
244 uint32_t smb_node_share_check(smb_node_t *, cred_t *,
245     uint32_t, uint32_t, smb_ofile_t *);
246 DWORD smb_node_rename_check(smb_node_t *);
247 DWORD smb_node_delete_check(smb_node_t *);
248 
249 uint64_t smb_node_get_size(smb_node_t *node, smb_attr_t *attr);
250 void smb_node_set_time(struct smb_node *node, timestruc_t *crtime,
251     timestruc_t *mtime, timestruc_t *atime,
252     timestruc_t *ctime, unsigned int what);
253 timestruc_t *smb_node_get_crtime(struct smb_node *node);
254 timestruc_t *smb_node_get_atime(struct smb_node *node);
255 timestruc_t *smb_node_get_ctime(struct smb_node *node);
256 timestruc_t *smb_node_get_mtime(struct smb_node *node);
257 void smb_node_set_dosattr(struct smb_node *, uint32_t);
258 uint32_t smb_node_get_dosattr(struct smb_node *node);
259 int smb_node_set_delete_on_close(smb_node_t *, cred_t *);
260 void smb_node_reset_delete_on_close(smb_node_t *);
261 
262 
263 
264 /*
265  * Pathname functions
266  */
267 
268 int smb_pathname_reduce(struct smb_request *, cred_t *,
269     const char *, smb_node_t *, smb_node_t *, smb_node_t **, char *);
270 
271 int smb_pathname(struct smb_request *, char *, int, smb_node_t *,
272     smb_node_t *, smb_node_t **, smb_node_t **, cred_t *);
273 
274 /*
275  * Share functions
276  */
277 
278 int smb_share_export(char *);
279 int smb_share_unexport(char *, char *);
280 
281 /*
282  * smb_vfs functions
283  */
284 
285 boolean_t smb_vfs_hold(vfs_t *);
286 void smb_vfs_rele(vfs_t *);
287 void smb_vfs_rele_all(void);
288 
289 /*
290  * String manipulation function
291  */
292 char *smb_kstrdup(const char *s, size_t n);
293 
294 int smb_sync_fsattr(struct smb_request *sr, cred_t *cr,
295     struct smb_node *node);
296 
297 int	smb_com_create_directory(struct smb_request *sr);
298 DWORD	smb_validate_dirname(char *path);
299 
300 int smb_com_trans2_create_directory(struct smb_request *sr, struct smb_xa *xa);
301 int smb_com_trans2_find_first2(struct smb_request *sr, struct smb_xa *xa);
302 int smb_com_trans2_find_next2(struct smb_request *sr, struct smb_xa *xa);
303 int smb_com_trans2_query_fs_information(struct smb_request *sr,
304     struct smb_xa *xa);
305 int smb_com_trans2_query_path_information(
306     struct smb_request *sr, struct smb_xa *xa);
307 int smb_com_trans2_query_file_information(
308     struct smb_request *sr, struct smb_xa *xa);
309 int smb_com_trans2_set_path_information(
310     struct smb_request *sr, struct smb_xa *xa);
311 int smb_com_trans2_set_file_information(
312     struct smb_request *sr, struct smb_xa *xa);
313 
314 void smb_encode_stream_info(struct smb_request *sr, struct smb_xa *xa,
315     smb_node_t *snode, smb_attr_t *attr);
316 
317 int smb_nt_transact_create(struct smb_request *sr, struct smb_xa *xa);
318 int smb_nt_transact_notify_change(struct smb_request *sr, struct smb_xa *xa);
319 int smb_nt_transact_query_security_info(struct smb_request *sr,
320     struct smb_xa *xa);
321 int smb_nt_transact_set_security_info(struct smb_request *sr,
322     struct smb_xa *xa);
323 int smb_nt_transact_ioctl(struct smb_request *sr, struct smb_xa *xa);
324 
325 /* NOTIFY CHANGE */
326 int smb_reply_notify_change_request(smb_request_t *sr);
327 void smb_process_session_notify_change_queue(struct smb_session *session);
328 void smb_process_node_notify_change_queue(struct smb_node *node);
329 void smb_reply_specific_cancel_request(struct smb_request *sr);
330 
331 void smb_fem_fcn_install(smb_node_t *node);
332 void smb_fem_fcn_uninstall(smb_node_t *node);
333 
334 /* FEM */
335 
336 int smb_fem_init();
337 void smb_fem_shutdown();
338 
339 int smb_try_grow(struct smb_request *sr, int64_t new_size);
340 
341 /* functions from smb_memory_manager.c */
342 
343 void	*smbsr_malloc(smb_malloc_list *, size_t);
344 void	*smbsr_realloc(void *, size_t);
345 void	smbsr_free_malloc_list(smb_malloc_list *);
346 
347 void smbsr_rq_notify(smb_request_t *sr,
348     smb_session_t *session, smb_tree_t *tree);
349 
350 unsigned short smb_worker_getnum();
351 int smb_common_close(struct smb_request *sr, uint32_t last_wtime);
352 void smb_preset_delete_on_close(struct smb_ofile *file);
353 void smb_commit_delete_on_close(struct smb_ofile *file);
354 
355 int smb_stream_parse_name(char *name, char *u_stream_name,
356     char *stream_name);
357 
358 uint32_t smb_get_gmtoff(void);
359 void smb_set_gmtoff(uint32_t);
360 
361 DWORD smb_trans2_set_information(struct smb_request *sr,
362     smb_trans2_setinfo_t *info,
363     smb_error_t *smberr);
364 
365 /* SMB signing routines smb_signing.c */
366 void smb_sign_init(struct smb_request *req,
367 	smb_session_key_t *session_key, char *resp, int resp_len);
368 
369 int smb_sign_check_request(struct smb_request *req);
370 
371 int smb_sign_check_secondary(struct smb_request *req, unsigned int seqnum);
372 
373 void smb_sign_reply(struct smb_request *req, struct mbuf_chain *reply);
374 
375 uint32_t smb_mode_to_dos_attributes(smb_attr_t *ap);
376 int smb_sattr_check(smb_attr_t *ap, char *name, unsigned short sattr);
377 
378 smb_request_t *smb_request_alloc(struct smb_session *session,
379     int request_length);
380 void smb_request_cancel(smb_request_t *sr);
381 void smb_request_free(smb_request_t *sr);
382 
383 smb_session_t *smb_session_create(struct sonode *new_so, uint16_t port);
384 void smb_session_delete(smb_session_t *session);
385 void smb_session_cancel(smb_session_t *session);
386 void smb_session_cancel_requests(smb_session_t *session);
387 void smb_session_config(smb_session_t *session);
388 void smb_session_reject(smb_session_t *session, char *reason);
389 void smb_session_disconnect_share(char *);
390 void smb_session_disconnect_volume(fs_desc_t *);
391 
392 
393 /*
394  * ofile functions (file smb_ofile.c)
395  */
396 smb_ofile_t *smb_ofile_lookup_by_fid(smb_tree_t *tree, uint16_t fid);
397 smb_ofile_t *smb_ofile_open(smb_tree_t *tree, smb_node_t *node, uint16_t pid,
398     uint32_t access_granted, uint32_t create_options, uint32_t share_access,
399     uint16_t ftype, char *pipe_name, uint32_t rpc_fid, uint32_t uniqid,
400     smb_error_t *err);
401 int smb_ofile_close(smb_ofile_t *ofile, uint32_t last_wtime);
402 uint32_t smb_ofile_access(smb_ofile_t *ofile, cred_t *cr, uint32_t access);
403 int smb_ofile_seek(smb_ofile_t *of, ushort_t mode, int32_t off,
404     uint32_t *retoff);
405 void smb_ofile_release(smb_ofile_t *ofile);
406 void smb_ofile_close_all(smb_tree_t *tree);
407 void smb_ofile_close_all_by_pid(smb_tree_t *tree, uint16_t pid);
408 void smb_ofile_set_flags(smb_ofile_t *of, uint32_t flags);
409 void smb_ofile_close_timestamp_update(smb_ofile_t *of, uint32_t last_wtime);
410 boolean_t smb_ofile_is_open(smb_ofile_t *of);
411 #define	smb_ofile_granted_access(_of_)	((_of_)->f_granted_access)
412 
413 /*
414  * odir functions (file smb_odir.c)
415  */
416 smb_odir_t *smb_odir_open(smb_tree_t *tree, smb_node_t *node, char *pattern,
417     uint16_t pid, unsigned short sattr);
418 void smb_odir_close(smb_odir_t *od);
419 void smb_odir_close_all(smb_tree_t *tree);
420 void smb_odir_close_all_by_pid(smb_tree_t *tree, uint16_t pid);
421 void smb_odir_release(smb_odir_t *od);
422 smb_odir_t *smb_odir_lookup_by_sid(smb_tree_t *tree, uint16_t sid);
423 
424 /*
425  * SMB user functions (file smb_user.c)
426  */
427 smb_user_t *smb_user_login(smb_session_t *, cred_t *,
428     char *, char *, uint32_t, uint32_t, uint32_t);
429 smb_user_t *smb_user_dup(smb_user_t *);
430 void smb_user_logoff(smb_user_t *user);
431 void smb_user_logoff_all(smb_session_t *session);
432 smb_user_t *smb_user_lookup_by_uid(smb_session_t *, cred_t **, uint16_t);
433 smb_user_t *smb_user_lookup_by_name(smb_session_t *, char *, char *);
434 smb_user_t *smb_user_lookup_by_state(smb_session_t *, smb_user_t *user);
435 void smb_user_disconnect_share(smb_user_t *user, char *sharename);
436 void smb_user_disconnect_volume(smb_user_t *user, fs_desc_t *fsd);
437 void smb_user_release(smb_user_t *user);
438 
439 /*
440  * SMB tree functions (file smb_tree.c)
441  */
442 smb_tree_t *smb_tree_connect(smb_user_t *user, uint16_t access_flags,
443     char *sharename, char *resource, int32_t rt_share,
444     smb_node_t *snode, fsvol_attr_t *vol_attr);
445 void smb_tree_disconnect(smb_tree_t *tree);
446 void smb_tree_disconnect_all(smb_user_t *user);
447 void smb_tree_close_all_by_pid(smb_user_t *user, uint16_t pid);
448 smb_tree_t *smb_tree_lookup_by_tid(smb_user_t *user, uint16_t tid);
449 smb_tree_t *smb_tree_lookup_by_name(smb_user_t *, char *, smb_tree_t *);
450 smb_tree_t *smb_tree_lookup_by_fsd(smb_user_t *, fs_desc_t *, smb_tree_t *);
451 void smb_tree_release(smb_tree_t *tree);
452 
453 uint32_t smb_user_get_num(void);
454 void smb_dr_user_free(smb_dr_user_ctx_t *uinfo);
455 void smb_dr_ulist_free(smb_dr_ulist_t *ulist);
456 int smb_dr_ulist_get(int offset, smb_dr_ulist_t *dr_ulist);
457 
458 /*
459  * SMB user's credential functions
460  */
461 cred_t *smb_cred_create(smb_token_t *, uint32_t *);
462 void smb_cred_rele(cred_t *cr);
463 int smb_cred_is_member(cred_t *cr, nt_sid_t *sid);
464 
465 smb_xa_t *smb_xa_create(smb_session_t *session, smb_request_t *sr,
466     uint32_t total_parameter_count, uint32_t total_data_count,
467     uint32_t max_parameter_count, uint32_t max_data_count,
468     uint32_t max_setup_count, uint32_t setup_word_count);
469 void smb_xa_delete(smb_xa_t *xa);
470 smb_xa_t *smb_xa_hold(smb_xa_t *xa);
471 void smb_xa_rele(smb_session_t *session, smb_xa_t *xa);
472 int smb_xa_open(smb_xa_t *xa);
473 void smb_xa_close(smb_xa_t *xa);
474 int smb_xa_complete(smb_xa_t *xa);
475 smb_xa_t *smb_xa_find(smb_session_t *session, uint16_t pid, uint16_t mid);
476 
477 struct mbuf *smb_mbuf_get(uchar_t *buf, int nbytes);
478 struct mbuf *smb_mbuf_allocate(struct uio *uio);
479 void smb_mbuf_trim(struct mbuf *mhead, int nbytes);
480 
481 void smb_check_status(void);
482 int smb_handle_write_raw(smb_session_t *session, smb_request_t *sr);
483 
484 void smb_winpipe_init(void);
485 void smb_winpipe_fini(void);
486 int smb_winpipe_open(int door_id);
487 void smb_winpipe_close(void);
488 int smb_winpipe_call(smb_request_t *, mlsvc_pipe_t *, mlsvc_stream_t *,
489     uint16_t, uint32_t *);
490 
491 void smb_reconnection_check(struct smb_session *session);
492 
493 uint32_t nt_to_unix_time(uint64_t nt_time, timestruc_t *unix_time);
494 uint64_t unix_to_nt_time(timestruc_t *);
495 
496 int netbios_name_isvalid(char *in, char *out);
497 
498 size_t
499 unicodestooems(char *oemstring, const mts_wchar_t *unicodestring,
500     size_t nbytes, unsigned int cpid);
501 
502 size_t oemstounicodes(mts_wchar_t *unicodestring, const char *oemstring,
503     size_t nwchars, unsigned int cpid);
504 
505 int uioxfer(struct uio *src_uio, struct uio *dst_uio, int n);
506 
507 int smb_match_name(ino64_t fileid, char *name, char *shortname,
508     char *name83, char *pattern, int ignore_case);
509 int is_dot_or_dotdot(char *name);
510 int token2buf(smb_token_t *token, char *buf);
511 
512 /*
513  * Pool ID function prototypes
514  */
515 int	smb_idpool_constructor(smb_idpool_t *pool);
516 void	smb_idpool_destructor(smb_idpool_t  *pool);
517 int	smb_idpool_alloc(smb_idpool_t *pool, uint16_t *id);
518 void	smb_idpool_free(smb_idpool_t *pool, uint16_t id);
519 
520 /*
521  * SMB thread function prototypes
522  */
523 void	smb_session_worker(void *arg);
524 
525 /*
526  * SMB locked list function prototypes
527  */
528 void	smb_llist_constructor(smb_llist_t *, size_t, size_t);
529 void	smb_llist_destructor(smb_llist_t *);
530 void	smb_llist_insert_head(smb_llist_t *ll, void *obj);
531 void	smb_llist_insert_tail(smb_llist_t *ll, void *obj);
532 void	smb_llist_remove(smb_llist_t *ll, void *obj);
533 int	smb_llist_upgrade(smb_llist_t *ll);
534 uint32_t smb_llist_get_count(smb_llist_t *ll);
535 #define	smb_llist_enter(ll, mode)	rw_enter(&(ll)->ll_lock, mode)
536 #define	smb_llist_exit(ll)		rw_exit(&(ll)->ll_lock)
537 #define	smb_llist_head(ll)		list_head(&(ll)->ll_list)
538 #define	smb_llist_next(ll, obj)		list_next(&(ll)->ll_list, obj)
539 int	smb_account_connected(smb_user_t *user);
540 
541 /*
542  * SMB Synchronized list function prototypes
543  */
544 void	smb_slist_constructor(smb_slist_t *, size_t, size_t);
545 void	smb_slist_destructor(smb_slist_t *);
546 void	smb_slist_insert_head(smb_slist_t *sl, void *obj);
547 void	smb_slist_insert_tail(smb_slist_t *sl, void *obj);
548 void	smb_slist_remove(smb_slist_t *sl, void *obj);
549 void	smb_slist_wait_for_empty(smb_slist_t *sl);
550 void	smb_slist_exit(smb_slist_t *sl);
551 uint32_t smb_slist_move_tail(list_t *lst, smb_slist_t *sl);
552 void    smb_slist_obj_move(smb_slist_t *dst, smb_slist_t *src, void *obj);
553 #define	smb_slist_enter(sl)		mutex_enter(&(sl)->sl_mutex)
554 #define	smb_slist_head(sl)		list_head(&(sl)->sl_list)
555 #define	smb_slist_next(sl, obj)		list_next(&(sl)->sl_list, obj)
556 
557 void    smb_rwx_init(smb_rwx_t *rwx);
558 void    smb_rwx_destroy(smb_rwx_t *rwx);
559 #define	smb_rwx_rwenter(rwx, mode)	rw_enter(&(rwx)->rwx_lock, mode)
560 void    smb_rwx_rwexit(smb_rwx_t *rwx);
561 int	smb_rwx_rwwait(smb_rwx_t *rwx, clock_t timeout);
562 #define	smb_rwx_xenter(rwx)		mutex_enter(&(rwx)->rwx_mutex)
563 #define	smb_rwx_xexit(rwx)		mutex_exit(&(rwx)->rwx_mutex)
564 krw_t   smb_rwx_rwupgrade(smb_rwx_t *rwx);
565 void    smb_rwx_rwdowngrade(smb_rwx_t *rwx, krw_t mode);
566 
567 void	smb_thread_init(smb_thread_t *, char *, smb_thread_ep_t, void *,
568     smb_thread_aw_t, void *);
569 void	smb_thread_destroy(smb_thread_t *);
570 int	smb_thread_start(smb_thread_t *);
571 void	smb_thread_stop(smb_thread_t *);
572 void    smb_thread_signal(smb_thread_t *);
573 boolean_t smb_thread_continue(smb_thread_t *);
574 boolean_t smb_thread_continue_nowait(smb_thread_t *);
575 boolean_t smb_thread_continue_timedwait(smb_thread_t *, int /* seconds */);
576 void smb_thread_set_awaken(smb_thread_t *, smb_thread_aw_t, void *);
577 
578 uint32_t smb_denymode_to_sharemode(uint32_t desired_access, char *fname);
579 uint32_t smb_ofun_to_crdisposition(uint16_t ofun);
580 
581 void    smb_audit_buf_node_create(smb_node_t *node);
582 void    smb_audit_buf_node_destroy(smb_node_t *node);
583 #define	smb_audit_node(_n_)					\
584 	if ((_n_)->n_audit_buf) {				\
585 		smb_audit_record_node_t	*anr;			\
586 								\
587 		anr = (_n_)->n_audit_buf->anb_records;		\
588 		anr += (_n_)->n_audit_buf->anb_index;		\
589 		(_n_)->n_audit_buf->anb_index++;		\
590 		(_n_)->n_audit_buf->anb_index &=		\
591 		    (_n_)->n_audit_buf->anb_max_index;		\
592 		anr->anr_refcnt = node->n_refcnt;		\
593 		anr->anr_depth = getpcstack(anr->anr_stack,	\
594 		    SMB_AUDIT_STACK_DEPTH);			\
595 	}
596 
597 /* 100's of ns between 1/1/1970 and 1/1/1601 */
598 #define	NT_TIME_BIAS	(134774LL * 24LL * 60LL * 60LL * 10000000LL)
599 
600 void smb_sd_init(smb_sd_t *, uint8_t);
601 void smb_sd_term(smb_sd_t *);
602 uint32_t smb_sd_get_secinfo(smb_sd_t *);
603 uint32_t smb_sd_len(smb_sd_t *, uint32_t);
604 uint32_t smb_sd_tofs(smb_sd_t *, smb_fssd_t *);
605 uint32_t smb_sd_read(smb_request_t *, smb_sd_t *, uint32_t);
606 uint32_t smb_sd_write(smb_request_t *, smb_sd_t *, uint32_t);
607 
608 void smb_fssd_init(smb_fssd_t *, uint32_t, uint32_t);
609 void smb_fssd_term(smb_fssd_t *);
610 
611 void smb_acl_sort(smb_acl_t *);
612 void smb_acl_free(smb_acl_t *);
613 smb_acl_t *smb_acl_alloc(uint8_t, uint16_t, uint16_t);
614 smb_acl_t *smb_acl_from_zfs(acl_t *, uid_t, gid_t);
615 uint32_t smb_acl_to_zfs(smb_acl_t *, uint32_t, int, acl_t **);
616 uint16_t smb_acl_len(smb_acl_t *);
617 boolean_t smb_acl_isvalid(smb_acl_t *, int);
618 
619 void smb_fsacl_free(acl_t *);
620 acl_t *smb_fsacl_alloc(int, int);
621 acl_t *smb_fsacl_inherit(acl_t *, int, int, uid_t);
622 acl_t *smb_fsacl_merge(acl_t *, acl_t *);
623 void smb_fsacl_split(acl_t *, acl_t **, acl_t **, int);
624 acl_t *smb_fsacl_from_vsa(vsecattr_t *, acl_type_t);
625 int smb_fsacl_to_vsa(acl_t *, vsecattr_t *, int *);
626 
627 boolean_t smb_ace_is_generic(int);
628 boolean_t smb_ace_is_access(int);
629 boolean_t smb_ace_is_audit(int);
630 
631 #ifdef	__cplusplus
632 }
633 #endif
634 
635 #endif /* _SMB_KPROTO_H_ */
636