1da6c28aaSamw /*
2da6c28aaSamw * CDDL HEADER START
3da6c28aaSamw *
4da6c28aaSamw * The contents of this file are subject to the terms of the
5da6c28aaSamw * Common Development and Distribution License (the "License").
6da6c28aaSamw * You may not use this file except in compliance with the License.
7da6c28aaSamw *
8da6c28aaSamw * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9da6c28aaSamw * or http://www.opensolaris.org/os/licensing.
10da6c28aaSamw * See the License for the specific language governing permissions
11da6c28aaSamw * and limitations under the License.
12da6c28aaSamw *
13da6c28aaSamw * When distributing Covered Code, include this CDDL HEADER in each
14da6c28aaSamw * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15da6c28aaSamw * If applicable, add the following below this CDDL HEADER, with the
16da6c28aaSamw * fields enclosed by brackets "[]" replaced with your own identifying
17da6c28aaSamw * information: Portions Copyright [yyyy] [name of copyright owner]
18da6c28aaSamw *
19da6c28aaSamw * CDDL HEADER END
20da6c28aaSamw */
21148c5f43SAlan Wright
22da6c28aaSamw /*
23148c5f43SAlan Wright * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
242a19195aSGordon Ross * Copyright 2017 Nexenta Systems, Inc. All rights reserved.
25da6c28aaSamw */
26da6c28aaSamw
27da6c28aaSamw /*
282c2961f8Sjose borrego * SMB requests.
29da6c28aaSamw *
30da6c28aaSamw * Request
31da6c28aaSamw * Header
32da6c28aaSamw * Magic 0xFF 'S' 'M' 'B'
33da6c28aaSamw * smb_com a byte, the "first" command
34da6c28aaSamw * Error a 4-byte union, ignored in a request
35da6c28aaSamw * smb_flg a one byte set of eight flags
36da6c28aaSamw * smb_flg2 a two byte set of 16 flags
37da6c28aaSamw * . twelve reserved bytes, have a role
38da6c28aaSamw * in connectionless transports (IPX, UDP?)
39da6c28aaSamw * smb_tid a 16-bit tree ID, a mount point sorta,
40da6c28aaSamw * 0xFFFF is this command does not have
41da6c28aaSamw * or require a tree context
42da6c28aaSamw * smb_pid a 16-bit process ID
43da6c28aaSamw * smb_uid a 16-bit user ID, specific to this "session"
44da6c28aaSamw * and mapped to a system (bona-fide) UID
45da6c28aaSamw * smb_mid a 16-bit multiplex ID, used to differentiate
46da6c28aaSamw * multiple simultaneous requests from the same
47da6c28aaSamw * process (pid) (ref RPC "xid")
48da6c28aaSamw *
49da6c28aaSamw * Chained (AndX) commands (0 or more)
50da6c28aaSamw * smb_wct a byte, number of 16-bit words containing
51da6c28aaSamw * command parameters, min 2 for chained command
52da6c28aaSamw * andx_com a byte, the "next" command, 0xFF for none
53da6c28aaSamw * . an unused byte
54da6c28aaSamw * andx_off a 16-bit offset, byte displacement from &Magic
55da6c28aaSamw * to the smb_wct field of the "next" command,
56da6c28aaSamw * ignore if andx_com is 0xFF, s/b 0 if no next
57da6c28aaSamw * smb_vwv[] 0 or more 16-bit (sorta) parameters for
58da6c28aaSamw * "this" command (i.e. smb_com if this is the
59da6c28aaSamw * first parameters, or the andx_com of the just
60da6c28aaSamw * previous block.
61da6c28aaSamw * smb_bcc a 16-bit count of smb_data[] bytes
62da6c28aaSamw * smb_data[] 0 or more bytes, format specific to commands
63da6c28aaSamw * padding[] Optional padding
64da6c28aaSamw *
65da6c28aaSamw * Last command
66da6c28aaSamw * smb_wct a byte, number of 16-bit words containing
67da6c28aaSamw * command parameters, min 0 for chained command
68da6c28aaSamw * smb_vwv[] 0 or more 16-bit (sorta) parameters for
69da6c28aaSamw * "this" command (i.e. smb_com if this is the
70da6c28aaSamw * first parameters, or the andx_com of the just
71da6c28aaSamw * previous block.
72da6c28aaSamw * smb_bcc a 16-bit count of smb_data[] bytes
73da6c28aaSamw * smb_data[] 0 or more bytes, format specific to commands
74da6c28aaSamw *
75da6c28aaSamw * Reply
76da6c28aaSamw * Header
77da6c28aaSamw * Magic 0xFF 'S' 'M' 'B'
78da6c28aaSamw * smb_com a byte, the "first" command, corresponds
79da6c28aaSamw * to request
80da6c28aaSamw * Error a 4-byte union, coding depends on dialect in use
81da6c28aaSamw * for "DOS" errors
82da6c28aaSamw * a byte for error class
83da6c28aaSamw * an unused byte
84da6c28aaSamw * a 16-bit word for error code
85da6c28aaSamw * for "NT" errors
86da6c28aaSamw * a 32-bit error code which
87da6c28aaSamw * is a packed class and specifier
88da6c28aaSamw * for "OS/2" errors
89da6c28aaSamw * I don't know
90da6c28aaSamw * The error information is specific to the
91da6c28aaSamw * last command in the reply chain.
92da6c28aaSamw * smb_flg a one byte set of eight flags, 0x80 bit set
93da6c28aaSamw * indicating this message is a reply
94da6c28aaSamw * smb_flg2 a two byte set of 16 flags
95da6c28aaSamw * . twelve reserved bytes, have a role
96da6c28aaSamw * in connectionless transports (IPX, UDP?)
97da6c28aaSamw * smb_tid a 16-bit tree ID, a mount point sorta,
98da6c28aaSamw * should be the same as the request
99da6c28aaSamw * smb_pid a 16-bit process ID, MUST BE the same as request
100da6c28aaSamw * smb_uid a 16-bit user ID, specific to this "session"
101da6c28aaSamw * and mapped to a system (bona-fide) UID,
102da6c28aaSamw * should be the same as request
103da6c28aaSamw * smb_mid a 16-bit multiplex ID, used to differentiate
104da6c28aaSamw * multiple simultaneous requests from the same
105da6c28aaSamw * process (pid) (ref RPC "xid"), MUST BE the
106da6c28aaSamw * same as request
107da6c28aaSamw * padding[] Optional padding
108da6c28aaSamw *
109da6c28aaSamw * Chained (AndX) commands (0 or more)
110da6c28aaSamw * smb_wct a byte, number of 16-bit words containing
111da6c28aaSamw * command parameters, min 2 for chained command,
112da6c28aaSamw * andx_com a byte, the "next" command, 0xFF for none,
113da6c28aaSamw * corresponds to request, if this is the chained
114da6c28aaSamw * command that had an error set to 0xFF
115da6c28aaSamw * . an unused byte
116da6c28aaSamw * andx_off a 16-bit offset, byte displacement from &Magic
117da6c28aaSamw * to the smb_wct field of the "next" command,
118da6c28aaSamw * ignore if andx_com is 0xFF, s/b 0 if no next
119da6c28aaSamw * smb_vwv[] 0 or more 16-bit (sorta) parameters for
120da6c28aaSamw * "this" command (i.e. smb_com if this is the
121da6c28aaSamw * first parameters, or the andx_com of the just
122da6c28aaSamw * previous block. Empty if an error.
123da6c28aaSamw * smb_bcc a 16-bit count of smb_data[] bytes
124da6c28aaSamw * smb_data[] 0 or more bytes, format specific to commands
125da6c28aaSamw * empty if an error.
126da6c28aaSamw *
127da6c28aaSamw * Last command
128da6c28aaSamw * smb_wct a byte, number of 16-bit words containing
129da6c28aaSamw * command parameters, min 0 for chained command
130da6c28aaSamw * smb_vwv[] 0 or more 16-bit (sorta) parameters for
131da6c28aaSamw * "this" command (i.e. smb_com if this is the
132da6c28aaSamw * first parameters, or the andx_com of the just
133da6c28aaSamw * previous block, empty if an error.
134da6c28aaSamw * smb_bcc a 16-bit count of smb_data[] bytes
135da6c28aaSamw * smb_data[] 0 or more bytes, format specific to commands,
136da6c28aaSamw * empty if an error.
137da6c28aaSamw */
138da6c28aaSamw
139bbf6f00cSJordan Brown #include <smbsrv/smb_kproto.h>
1406537f381Sas200622 #include <smbsrv/smb_kstat.h>
141da6c28aaSamw #include <sys/sdt.h>
142148c5f43SAlan Wright #include <sys/spl.h>
143da6c28aaSamw
144da6c28aaSamw static int is_andx_com(unsigned char);
1457b59d02dSjb150015 static int smbsr_check_result(struct smb_request *, int, int);
146a90cf9f2SGordon Ross static void smb1_tq_work(void *);
147da6c28aaSamw
148adb064afSToomas Soome static const smb_disp_entry_t
1498622ec45SGordon Ross smb_disp_table[SMB_COM_NUM] = {
150148c5f43SAlan Wright { "SmbCreateDirectory", SMB_SDT_OPS(create_directory), /* 0x00 000 */
151148c5f43SAlan Wright 0x00, PC_NETWORK_PROGRAM_1_0 },
152148c5f43SAlan Wright { "SmbDeleteDirectory", SMB_SDT_OPS(delete_directory), /* 0x01 001 */
153148c5f43SAlan Wright 0x01, PC_NETWORK_PROGRAM_1_0 },
154148c5f43SAlan Wright { "SmbOpen", SMB_SDT_OPS(open), /* 0x02 002 */
155148c5f43SAlan Wright 0x02, PC_NETWORK_PROGRAM_1_0 },
156148c5f43SAlan Wright { "SmbCreate", SMB_SDT_OPS(create), /* 0x03 003 */
157148c5f43SAlan Wright 0x03, PC_NETWORK_PROGRAM_1_0 },
158148c5f43SAlan Wright { "SmbClose", SMB_SDT_OPS(close), /* 0x04 004 */
159148c5f43SAlan Wright 0x04, PC_NETWORK_PROGRAM_1_0 },
160148c5f43SAlan Wright { "SmbFlush", SMB_SDT_OPS(flush), /* 0x05 005 */
161148c5f43SAlan Wright 0x05, PC_NETWORK_PROGRAM_1_0 },
162148c5f43SAlan Wright { "SmbDelete", SMB_SDT_OPS(delete), /* 0x06 006 */
163148c5f43SAlan Wright 0x06, PC_NETWORK_PROGRAM_1_0 },
164148c5f43SAlan Wright { "SmbRename", SMB_SDT_OPS(rename), /* 0x07 007 */
165148c5f43SAlan Wright 0x07, PC_NETWORK_PROGRAM_1_0 },
166148c5f43SAlan Wright { "SmbQueryInformation", SMB_SDT_OPS(query_information), /* 0x08 008 */
167148c5f43SAlan Wright 0x08, PC_NETWORK_PROGRAM_1_0 },
168148c5f43SAlan Wright { "SmbSetInformation", SMB_SDT_OPS(set_information), /* 0x09 009 */
169148c5f43SAlan Wright 0x09, PC_NETWORK_PROGRAM_1_0 },
170148c5f43SAlan Wright { "SmbRead", SMB_SDT_OPS(read), /* 0x0A 010 */
171148c5f43SAlan Wright 0x0A, PC_NETWORK_PROGRAM_1_0 },
172148c5f43SAlan Wright { "SmbWrite", SMB_SDT_OPS(write), /* 0x0B 011 */
173148c5f43SAlan Wright 0x0B, PC_NETWORK_PROGRAM_1_0 },
174148c5f43SAlan Wright { "SmbLockByteRange", SMB_SDT_OPS(lock_byte_range), /* 0x0C 012 */
175148c5f43SAlan Wright 0x0C, PC_NETWORK_PROGRAM_1_0 },
176148c5f43SAlan Wright { "SmbUnlockByteRange", SMB_SDT_OPS(unlock_byte_range), /* 0x0D 013 */
177148c5f43SAlan Wright 0x0D, PC_NETWORK_PROGRAM_1_0 },
178148c5f43SAlan Wright { "SmbCreateTemporary", SMB_SDT_OPS(create_temporary), /* 0x0E 014 */
179148c5f43SAlan Wright 0x0E, PC_NETWORK_PROGRAM_1_0 },
180148c5f43SAlan Wright { "SmbCreateNew", SMB_SDT_OPS(create_new), /* 0x0F 015 */
181148c5f43SAlan Wright 0x0F, PC_NETWORK_PROGRAM_1_0 },
182148c5f43SAlan Wright { "SmbCheckDirectory", SMB_SDT_OPS(check_directory), /* 0x10 016 */
183148c5f43SAlan Wright 0x10, PC_NETWORK_PROGRAM_1_0 },
184148c5f43SAlan Wright { "SmbProcessExit", SMB_SDT_OPS(process_exit), /* 0x11 017 */
1858622ec45SGordon Ross 0x11, PC_NETWORK_PROGRAM_1_0,
1868622ec45SGordon Ross SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID },
187148c5f43SAlan Wright { "SmbSeek", SMB_SDT_OPS(seek), /* 0x12 018 */
188148c5f43SAlan Wright 0x12, PC_NETWORK_PROGRAM_1_0 },
189148c5f43SAlan Wright { "SmbLockAndRead", SMB_SDT_OPS(lock_and_read), /* 0x13 019 */
190148c5f43SAlan Wright 0x13, LANMAN1_0 },
191148c5f43SAlan Wright { "SmbWriteAndUnlock", SMB_SDT_OPS(write_and_unlock), /* 0x14 020 */
192148c5f43SAlan Wright 0x14, LANMAN1_0 },
193148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x15, 0 }, /* 0x15 021 */
194148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x16, 0 }, /* 0x16 022 */
195148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x17, 0 }, /* 0x17 023 */
196148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x18, 0 }, /* 0x18 024 */
197148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x19, 0 }, /* 0x19 025 */
19893bc28dbSGordon Ross { "SmbReadRaw", SMB_SDT_OPS(read_raw), /* 0x1A 026 */
19993bc28dbSGordon Ross 0x1A, LANMAN1_0 },
200148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x1B, 0 }, /* 0x1B 027 */
201148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x1C, 0 }, /* 0x1C 028 */
20293bc28dbSGordon Ross { "SmbWriteRaw", SMB_SDT_OPS(write_raw), /* 0x1D 029 */
20393bc28dbSGordon Ross 0x1D, LANMAN1_0 },
204148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x1E, 0 }, /* 0x1E 030 */
205148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x1F, 0 }, /* 0x1F 031 */
206148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x20, 0 }, /* 0x20 032 */
207148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x21, 0 }, /* 0x21 033 */
208148c5f43SAlan Wright { "SmbSetInformation2", SMB_SDT_OPS(set_information2), /* 0x22 034 */
209148c5f43SAlan Wright 0x22, LANMAN1_0 },
210148c5f43SAlan Wright { "SmbQueryInformation2",
211148c5f43SAlan Wright SMB_SDT_OPS(query_information2), /* 0x23 035 */
212148c5f43SAlan Wright 0x23, LANMAN1_0 },
213148c5f43SAlan Wright { "SmbLockingX", SMB_SDT_OPS(locking_andx), /* 0x24 036 */
214148c5f43SAlan Wright 0x24, LANMAN1_0 },
215148c5f43SAlan Wright { "SmbTransaction", SMB_SDT_OPS(transaction), /* 0x25 037 */
216148c5f43SAlan Wright 0x25, LANMAN1_0 },
217148c5f43SAlan Wright { "SmbTransactionSecondary",
218148c5f43SAlan Wright SMB_SDT_OPS(transaction_secondary), /* 0x26 038 */
219148c5f43SAlan Wright 0x26, LANMAN1_0 },
220148c5f43SAlan Wright { "SmbIoctl", SMB_SDT_OPS(ioctl), /* 0x27 039 */
221148c5f43SAlan Wright 0x27, LANMAN1_0 },
222148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x28, 0 }, /* 0x28 040 */
223148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x29, 0 }, /* 0x29 041 */
224148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x2A, 0 }, /* 0x2A 042 */
225148c5f43SAlan Wright { "SmbEcho", SMB_SDT_OPS(echo), /* 0x2B 043 */
226148c5f43SAlan Wright 0x2B, LANMAN1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID },
227148c5f43SAlan Wright { "SmbWriteAndClose", SMB_SDT_OPS(write_and_close), /* 0x2C 044 */
228148c5f43SAlan Wright 0x2C, LANMAN1_0 },
229148c5f43SAlan Wright { "SmbOpenX", SMB_SDT_OPS(open_andx), /* 0x2D 045 */
230148c5f43SAlan Wright 0x2D, LANMAN1_0 },
231148c5f43SAlan Wright { "SmbReadX", SMB_SDT_OPS(read_andx), /* 0x2E 046 */
232148c5f43SAlan Wright 0x2E, LANMAN1_0 },
233148c5f43SAlan Wright { "SmbWriteX", SMB_SDT_OPS(write_andx), /* 0x2F 047 */
234148c5f43SAlan Wright 0x2F, LANMAN1_0 },
235148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x30, 0 }, /* 0x30 048 */
236148c5f43SAlan Wright { "SmbCloseAndTreeDisconnect",
237148c5f43SAlan Wright SMB_SDT_OPS(close_and_tree_disconnect), /* 0x31 049 */
238148c5f43SAlan Wright 0x31, LANMAN1_0 },
239148c5f43SAlan Wright { "SmbTransaction2", SMB_SDT_OPS(transaction2), /* 0x32 050 */
240148c5f43SAlan Wright 0x32, LM1_2X002 },
241148c5f43SAlan Wright { "SmbTransaction2Secondary",
242148c5f43SAlan Wright SMB_SDT_OPS(transaction2_secondary), /* 0x33 051 */
243148c5f43SAlan Wright 0x33, LM1_2X002 },
244148c5f43SAlan Wright { "SmbFindClose2", SMB_SDT_OPS(find_close2), /* 0x34 052 */
245148c5f43SAlan Wright 0x34, LM1_2X002 },
246148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x35, 0 }, /* 0x35 053 */
247148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x36, 0 }, /* 0x36 054 */
248148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x37, 0 }, /* 0x37 055 */
249148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x38, 0 }, /* 0x38 056 */
250148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x39, 0 }, /* 0x39 057 */
251148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3A, 0 }, /* 0x3A 058 */
252148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3B, 0 }, /* 0x3B 059 */
253148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3C, 0 }, /* 0x3C 060 */
254148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3D, 0 }, /* 0x3D 061 */
255148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3E, 0 }, /* 0x3E 062 */
256148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x3F, 0 }, /* 0x3F 063 */
257148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x40, 0 }, /* 0x40 064 */
258148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x47, 0 }, /* 0x47 065 */
259148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x48, 0 }, /* 0x48 066 */
260148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x49, 0 }, /* 0x49 067 */
261148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x44, 0 }, /* 0x44 068 */
262148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x45, 0 }, /* 0x45 069 */
263148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x46, 0 }, /* 0x46 070 */
264148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x47, 0 }, /* 0x47 071 */
265148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x48, 0 }, /* 0x48 072 */
266148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x49, 0 }, /* 0x49 073 */
267148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4A, 0 }, /* 0x4A 074 */
268148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4B, 0 }, /* 0x4B 075 */
269148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4C, 0 }, /* 0x4C 076 */
270148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4D, 0 }, /* 0x4D 077 */
271148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4E, 0 }, /* 0x4E 078 */
272148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x4F, 0 }, /* 0x4F 079 */
273148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x50, 0 }, /* 0x50 080 */
274148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x51, 0 }, /* 0x51 081 */
275148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x52, 0 }, /* 0x52 082 */
276148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x53, 0 }, /* 0x53 083 */
277148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x54, 0 }, /* 0x54 084 */
278148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x55, 0 }, /* 0x55 085 */
279148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x56, 0 }, /* 0x56 086 */
280148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x57, 0 }, /* 0x57 087 */
281148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x58, 0 }, /* 0x58 088 */
282148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x59, 0 }, /* 0x59 089 */
283148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5A, 0 }, /* 0x5A 090 */
284148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5B, 0 }, /* 0x5B 091 */
285148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5C, 0 }, /* 0x5C 092 */
286148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5D, 0 }, /* 0x5D 093 */
287148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5E, 0 }, /* 0x5E 094 */
288148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x5F, 0 }, /* 0x5F 095 */
289148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x60, 0 }, /* 0x60 096 */
290148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x61, 0 }, /* 0x61 097 */
291148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x62, 0 }, /* 0x62 098 */
292148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x63, 0 }, /* 0x63 099 */
293148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x64, 0 }, /* 0x64 100 */
294148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x65, 0 }, /* 0x65 101 */
295148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x66, 0 }, /* 0x66 102 */
296148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x67, 0 }, /* 0x67 103 */
297148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x68, 0 }, /* 0x68 104 */
298148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x69, 0 }, /* 0x69 105 */
299148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6A, 0 }, /* 0x6A 106 */
300148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6B, 0 }, /* 0x6B 107 */
301148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6C, 0 }, /* 0x6C 108 */
302148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6D, 0 }, /* 0x6D 109 */
303148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6E, 0 }, /* 0x6E 110 */
304148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x6F, 0 }, /* 0x6F 111 */
305148c5f43SAlan Wright { "SmbTreeConnect", SMB_SDT_OPS(tree_connect), /* 0x70 112 */
306148c5f43SAlan Wright 0x70, PC_NETWORK_PROGRAM_1_0, SDDF_SUPPRESS_TID },
307148c5f43SAlan Wright { "SmbTreeDisconnect", SMB_SDT_OPS(tree_disconnect), /* 0x71 113 */
3088622ec45SGordon Ross 0x71, PC_NETWORK_PROGRAM_1_0,
3098622ec45SGordon Ross SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID },
310a90cf9f2SGordon Ross /*
311a90cf9f2SGordon Ross * NB: Negotiate gets special handling via
312a90cf9f2SGordon Ross * smb_initial_request_handler. After that,
313a90cf9f2SGordon Ross * another Negotiate is an invalid request.
314a90cf9f2SGordon Ross */
315a90cf9f2SGordon Ross { "SmbNegotiate", SMB_SDT_OPS(invalid), /* 0x72 114 */
3168622ec45SGordon Ross 0x72, PC_NETWORK_PROGRAM_1_0,
3178622ec45SGordon Ross SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID },
318148c5f43SAlan Wright { "SmbSessionSetupX", SMB_SDT_OPS(session_setup_andx), /* 0x73 115 */
319148c5f43SAlan Wright 0x73, LANMAN1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID },
320148c5f43SAlan Wright { "SmbLogoffX", SMB_SDT_OPS(logoff_andx), /* 0x74 116 */
321148c5f43SAlan Wright 0x74, LM1_2X002, SDDF_SUPPRESS_TID },
322148c5f43SAlan Wright { "SmbTreeConnectX", SMB_SDT_OPS(tree_connect_andx), /* 0x75 117 */
323148c5f43SAlan Wright 0x75, LANMAN1_0, SDDF_SUPPRESS_TID },
324148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x76, 0, 0 }, /* 0x76 118 */
325148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x77, 0, 0 }, /* 0x77 119 */
326148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x78, 0, 0 }, /* 0x78 120 */
327148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x79, 0, 0 }, /* 0x79 121 */
328148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7A, 0, 0 }, /* 0x7A 122 */
329148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7B, 0, 0 }, /* 0x7B 123 */
330148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7C, 0, 0 }, /* 0x7C 124 */
331148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7D, 0, 0 }, /* 0x7D 125 */
332148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7E, 0, 0 }, /* 0x7E 126 */
333148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x7F, 0, 0 }, /* 0x7F 127 */
334148c5f43SAlan Wright { "SmbQueryInformationDisk",
335148c5f43SAlan Wright SMB_SDT_OPS(query_information_disk), /* 0x80 128 */
336148c5f43SAlan Wright 0x80, PC_NETWORK_PROGRAM_1_0, 0 },
337148c5f43SAlan Wright { "SmbSearch", SMB_SDT_OPS(search), /* 0x81 129 */
338148c5f43SAlan Wright 0x81, PC_NETWORK_PROGRAM_1_0, 0 },
339148c5f43SAlan Wright { "SmbFind", SMB_SDT_OPS(find), /* 0x82 130 */
340148c5f43SAlan Wright 0x82, LANMAN1_0, 0 },
341148c5f43SAlan Wright { "SmbFindUnique", SMB_SDT_OPS(find_unique), /* 0x83 131 */
342148c5f43SAlan Wright 0x83, LANMAN1_0, 0 },
343148c5f43SAlan Wright { "SmbFindClose", SMB_SDT_OPS(find_close), /* 0x84 132 */
344148c5f43SAlan Wright 0x84, LANMAN1_0, 0 },
345148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x85, 0, 0 }, /* 0x85 133 */
346148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x86, 0, 0 }, /* 0x86 134 */
347148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x87, 0, 0 }, /* 0x87 135 */
348148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x88, 0, 0 }, /* 0x88 136 */
349148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x89, 0, 0 }, /* 0x89 137 */
350148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8A, 0, 0 }, /* 0x8A 138 */
351148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8B, 0, 0 }, /* 0x8B 139 */
352148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8C, 0, 0 }, /* 0x8C 140 */
353148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8D, 0, 0 }, /* 0x8D 141 */
354148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8E, 0, 0 }, /* 0x8E 142 */
355148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x8F, 0, 0 }, /* 0x8F 143 */
356148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x90, 0, 0 }, /* 0x90 144 */
357148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x91, 0, 0 }, /* 0x91 145 */
358148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x92, 0, 0 }, /* 0x92 146 */
359148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x93, 0, 0 }, /* 0x93 147 */
360148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x94, 0, 0 }, /* 0x94 148 */
361148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x95, 0, 0 }, /* 0x95 149 */
362148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x96, 0, 0 }, /* 0x96 150 */
363148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x97, 0, 0 }, /* 0x97 151 */
364148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x98, 0, 0 }, /* 0x98 152 */
365148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x99, 0, 0 }, /* 0x99 153 */
366148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9A, 0, 0 }, /* 0x9A 154 */
367148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9B, 0, 0 }, /* 0x9B 155 */
368148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9C, 0, 0 }, /* 0x9C 156 */
369148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9D, 0, 0 }, /* 0x9D 157 */
370148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9E, 0, 0 }, /* 0x9E 158 */
371148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0x9F, 0, 0 }, /* 0x9F 159 */
372148c5f43SAlan Wright { "SmbNtTransact", SMB_SDT_OPS(nt_transact), /* 0xA0 160 */
373148c5f43SAlan Wright 0xA0, NT_LM_0_12, 0 },
374148c5f43SAlan Wright { "SmbNtTransactSecondary",
375148c5f43SAlan Wright SMB_SDT_OPS(nt_transact_secondary), /* 0xA1 161 */
376148c5f43SAlan Wright 0xA1, NT_LM_0_12, 0 },
377148c5f43SAlan Wright { "SmbNtCreateX", SMB_SDT_OPS(nt_create_andx), /* 0xA2 162 */
378148c5f43SAlan Wright 0xA2, NT_LM_0_12, 0 },
379148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xA3, 0, 0 }, /* 0xA3 163 */
380148c5f43SAlan Wright { "SmbNtCancel", SMB_SDT_OPS(nt_cancel), /* 0xA4 164 */
381148c5f43SAlan Wright 0xA4, NT_LM_0_12, 0 },
382148c5f43SAlan Wright { "SmbNtRename", SMB_SDT_OPS(nt_rename), /* 0xA5 165 */
383148c5f43SAlan Wright 0xA5, NT_LM_0_12, 0 },
384148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xA6, 0, 0 }, /* 0xA6 166 */
385148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xA7, 0, 0 }, /* 0xA7 167 */
386148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xA8, 0, 0 }, /* 0xA8 168 */
387148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xA9, 0, 0 }, /* 0xA9 169 */
388148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAA, 0, 0 }, /* 0xAA 170 */
389148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAB, 0, 0 }, /* 0xAB 171 */
390148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAC, 0, 0 }, /* 0xAC 172 */
391148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAD, 0, 0 }, /* 0xAD 173 */
392148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAE, 0, 0 }, /* 0xAE 174 */
393148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xAF, 0, 0 }, /* 0xAF 175 */
394148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB0, 0, 0 }, /* 0xB0 176 */
395148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB1, 0, 0 }, /* 0xB1 177 */
396148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB2, 0, 0 }, /* 0xB2 178 */
397148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB3, 0, 0 }, /* 0xB3 179 */
398148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB4, 0, 0 }, /* 0xB4 180 */
399148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB5, 0, 0 }, /* 0xB5 181 */
400148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB6, 0, 0 }, /* 0xB6 182 */
401148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB7, 0, 0 }, /* 0xB7 183 */
402148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB8, 0, 0 }, /* 0xB8 184 */
403148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xB9, 0, 0 }, /* 0xB9 185 */
404148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBA, 0, 0 }, /* 0xBA 186 */
405148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBB, 0, 0 }, /* 0xBB 187 */
406148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBC, 0, 0 }, /* 0xBC 188 */
407148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBD, 0, 0 }, /* 0xBD 189 */
408148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBE, 0, 0 }, /* 0xBE 190 */
409148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xBF, 0, 0 }, /* 0xBF 191 */
410148c5f43SAlan Wright { "SmbOpenPrintFile", SMB_SDT_OPS(open_print_file), /* 0xC0 192 */
411148c5f43SAlan Wright 0xC0, PC_NETWORK_PROGRAM_1_0, 0 },
412148c5f43SAlan Wright { "SmbWritePrintFile", SMB_SDT_OPS(write_print_file), /* 0xC1 193 */
413148c5f43SAlan Wright 0xC1, PC_NETWORK_PROGRAM_1_0, 0 },
414148c5f43SAlan Wright { "SmbClosePrintFile", SMB_SDT_OPS(close_print_file), /* 0xC2 194 */
415148c5f43SAlan Wright 0xC2, PC_NETWORK_PROGRAM_1_0, 0 },
416148c5f43SAlan Wright { "SmbGetPrintQueue", SMB_SDT_OPS(get_print_queue), /* 0xC3 195 */
417148c5f43SAlan Wright 0xC3, PC_NETWORK_PROGRAM_1_0, 0 },
418148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC4, 0, 0 }, /* 0xC4 196 */
419148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC5, 0, 0 }, /* 0xC5 197 */
420148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC6, 0, 0 }, /* 0xC6 198 */
421148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC7, 0, 0 }, /* 0xC7 199 */
422148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC8, 0, 0 }, /* 0xC8 200 */
423148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xC9, 0, 0 }, /* 0xC9 201 */
424148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCA, 0, 0 }, /* 0xCA 202 */
425148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCB, 0, 0 }, /* 0xCB 203 */
426148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCC, 0, 0 }, /* 0xCC 204 */
427148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCD, 0, 0 }, /* 0xCD 205 */
428148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCE, 0, 0 }, /* 0xCE 206 */
429148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xCF, 0, 0 }, /* 0xCF 207 */
430148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD0, 0, 0 }, /* 0xD0 208 */
431148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD1, 0, 0 }, /* 0xD1 209 */
432148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD2, 0, 0 }, /* 0xD2 210 */
433148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD3, 0, 0 }, /* 0xD3 211 */
434148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD4, 0, 0 }, /* 0xD4 212 */
435148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD5, 0, 0 }, /* 0xD5 213 */
436148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD6, 0, 0 }, /* 0xD6 214 */
437148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD7, 0, 0 }, /* 0xD7 215 */
438148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD8, 0, 0 }, /* 0xD8 216 */
439148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xD9, 0, 0 }, /* 0xD9 217 */
440148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDA, 0, 0 }, /* 0xDA 218 */
441148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDB, 0, 0 }, /* 0xDB 219 */
442148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDC, 0, 0 }, /* 0xDC 220 */
443148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDD, 0, 0 }, /* 0xDD 221 */
444148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDE, 0, 0 }, /* 0xDE 222 */
445148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xDF, 0, 0 }, /* 0xDF 223 */
446148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE0, 0, 0 }, /* 0xE0 224 */
447148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE1, 0, 0 }, /* 0xE1 225 */
448148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE2, 0, 0 }, /* 0xE2 226 */
449148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE3, 0, 0 }, /* 0xE3 227 */
450148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE4, 0, 0 }, /* 0xE4 228 */
451148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE5, 0, 0 }, /* 0xE5 229 */
452148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE6, 0, 0 }, /* 0xE6 230 */
453148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE7, 0, 0 }, /* 0xE7 231 */
454148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE8, 0, 0 }, /* 0xE8 232 */
455148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xE9, 0, 0 }, /* 0xE9 233 */
456148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xEA, 0, 0 }, /* 0xEA 234 */
457148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xEB, 0, 0 }, /* 0xEB 235 */
458148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xEC, 0, 0 }, /* 0xEC 236 */
459148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xED, 0, 0 }, /* 0xED 237 */
460148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xEE, 0, 0 }, /* 0xEE 238 */
461148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xEF, 0, 0 }, /* 0xEF 239 */
462148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF0, 0, 0 }, /* 0xF0 240 */
463148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF1, 0, 0 }, /* 0xF1 241 */
464148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF2, 0, 0 }, /* 0xF2 242 */
465148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF3, 0, 0 }, /* 0xF3 243 */
466148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF4, 0, 0 }, /* 0xF4 244 */
467148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF5, 0, 0 }, /* 0xF5 245 */
468148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF6, 0, 0 }, /* 0xF6 246 */
469148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF7, 0, 0 }, /* 0xF7 247 */
470148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF8, 0, 0 }, /* 0xF8 248 */
471148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xF9, 0, 0 }, /* 0xF9 249 */
472148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFA, 0, 0 }, /* 0xFA 250 */
473148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFB, 0, 0 }, /* 0xFB 251 */
474148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFC, 0, 0 }, /* 0xFC 252 */
475148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFD, 0, 0 }, /* 0xFD 253 */
476148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFE, 0, 0 }, /* 0xFE 254 */
477148c5f43SAlan Wright { "Invalid", SMB_SDT_OPS(invalid), 0xFF, 0, 0 } /* 0xFF 255 */
478da6c28aaSamw };
479da6c28aaSamw
480da6c28aaSamw /*
481da6c28aaSamw * smbsr_cleanup
482da6c28aaSamw *
483da6c28aaSamw * If any user/tree/file is used by given request then
484da6c28aaSamw * the reference count for that resource has been incremented.
485da6c28aaSamw * This function decrements the reference count and close
486da6c28aaSamw * the resource if it's needed.
487da6c28aaSamw */
488da6c28aaSamw
489da6c28aaSamw void
smbsr_cleanup(smb_request_t * sr)490faa1795aSjb150015 smbsr_cleanup(smb_request_t *sr)
491da6c28aaSamw {
492da6c28aaSamw ASSERT((sr->sr_state != SMB_REQ_STATE_CLEANED_UP) &&
493da6c28aaSamw (sr->sr_state != SMB_REQ_STATE_COMPLETED));
494da6c28aaSamw
495da6c28aaSamw if (sr->r_xa) {
496da6c28aaSamw if (sr->r_xa->xa_flags & SMB_XA_FLAG_COMPLETE)
497da6c28aaSamw smb_xa_close(sr->r_xa);
498da6c28aaSamw smb_xa_rele(sr->session, sr->r_xa);
499da6c28aaSamw sr->r_xa = NULL;
500da6c28aaSamw }
501da6c28aaSamw
502da6c28aaSamw /*
503da6c28aaSamw * Mark this request so we know that we've already cleaned it up.
504da6c28aaSamw * A request should only get cleaned up once so multiple calls to
505da6c28aaSamw * smbsr_cleanup for the same request indicate a bug.
506da6c28aaSamw */
507da6c28aaSamw mutex_enter(&sr->sr_mutex);
5085677e049SGordon Ross if (sr->sr_state != SMB_REQ_STATE_CANCELLED)
509da6c28aaSamw sr->sr_state = SMB_REQ_STATE_CLEANED_UP;
510da6c28aaSamw mutex_exit(&sr->sr_mutex);
511da6c28aaSamw }
512a90cf9f2SGordon Ross
5135677e049SGordon Ross int smb_cancel_in_reader = 1;
5145677e049SGordon Ross
51559229f98Sjose borrego /*
516a90cf9f2SGordon Ross * This is the SMB1 handler for new smb requests, called from
517a90cf9f2SGordon Ross * smb_session_reader after SMB negotiate is done. For most SMB
518a90cf9f2SGordon Ross * requests, we just enqueue them for the smb_session_worker to
519a90cf9f2SGordon Ross * execute via the task queue, so they can block for resources
520a90cf9f2SGordon Ross * without stopping the reader thread. A few protocol messages
521a90cf9f2SGordon Ross * are special cases and are handled directly here in the reader
522a90cf9f2SGordon Ross * thread so they don't wait for taskq scheduling. Later, a few
523a90cf9f2SGordon Ross * MORE things could be handled here, such as REPLY messages
524a90cf9f2SGordon Ross * (oplock break reply) and things like "NT_cancel".
52559229f98Sjose borrego *
526a90cf9f2SGordon Ross * This function must either enqueue the new request for
527a90cf9f2SGordon Ross * execution via the task queue, or execute it directly
528a90cf9f2SGordon Ross * and then free it. If this returns non-zero, the caller
529a90cf9f2SGordon Ross * will drop the session.
53059229f98Sjose borrego */
531a90cf9f2SGordon Ross int
smb1sr_newrq(smb_request_t * sr)532a90cf9f2SGordon Ross smb1sr_newrq(smb_request_t *sr)
533a90cf9f2SGordon Ross {
5345677e049SGordon Ross uint16_t pid_hi, pid_lo;
5355677e049SGordon Ross int rc, save_offset;
536*9788d6deSGordon Ross taskqid_t tqid;
537a90cf9f2SGordon Ross
5385677e049SGordon Ross /*
5395677e049SGordon Ross * Decode the SMB header now (peek) so that
5405677e049SGordon Ross * SMB_COM_NT_CANCEL can find this SR.
5415677e049SGordon Ross */
5425677e049SGordon Ross save_offset = sr->command.chain_offset;
5435677e049SGordon Ross rc = smb_mbc_decodef(&sr->command, SMB_HEADER_ED_FMT,
5445677e049SGordon Ross &sr->smb_com,
5455677e049SGordon Ross &sr->smb_rcls,
5465677e049SGordon Ross &sr->smb_reh,
5475677e049SGordon Ross &sr->smb_err,
5485677e049SGordon Ross &sr->smb_flg,
5495677e049SGordon Ross &sr->smb_flg2,
5505677e049SGordon Ross &pid_hi,
5515677e049SGordon Ross sr->smb_sig,
5525677e049SGordon Ross &sr->smb_tid,
5535677e049SGordon Ross &pid_lo,
5545677e049SGordon Ross &sr->smb_uid,
5555677e049SGordon Ross &sr->smb_mid);
5565677e049SGordon Ross sr->command.chain_offset = save_offset;
5575677e049SGordon Ross if (rc != 0) {
5585677e049SGordon Ross /* Failed decoding the header. Drop 'em. */
559a90cf9f2SGordon Ross smb_request_free(sr);
560a90cf9f2SGordon Ross return (EPROTO);
561a90cf9f2SGordon Ross }
5625677e049SGordon Ross sr->smb_pid = (pid_hi << 16) | pid_lo;
563a90cf9f2SGordon Ross
5645677e049SGordon Ross if (sr->smb_com == SMB_COM_NT_CANCEL) {
565a90cf9f2SGordon Ross if (sr->session->signing.flags & SMB_SIGNING_ENABLED) {
566a90cf9f2SGordon Ross sr->session->signing.seqnum++;
567a90cf9f2SGordon Ross sr->sr_seqnum = sr->session->signing.seqnum + 1;
568a90cf9f2SGordon Ross sr->reply_seqnum = 0;
5695677e049SGordon Ross }
5705677e049SGordon Ross
5715677e049SGordon Ross /*
5725677e049SGordon Ross * Normally execute cancel requests immediately,
5735677e049SGordon Ross * (here in the reader thread) so they won't wait
5745677e049SGordon Ross * for other commands already in the task queue.
5755677e049SGordon Ross * Disable this via smb_cancel_in_reader=0 for
5765677e049SGordon Ross * testing or diagnostic efforts, in which case
5775677e049SGordon Ross * cancel runs via taskq_dispatch.
5785677e049SGordon Ross */
5795677e049SGordon Ross if (smb_cancel_in_reader != 0) {
5805677e049SGordon Ross rc = smb1sr_newrq_cancel(sr);
5815677e049SGordon Ross smb_request_free(sr);
5825677e049SGordon Ross return (rc);
5835677e049SGordon Ross }
584a90cf9f2SGordon Ross } else {
5855677e049SGordon Ross /* not NT cancel */
5865677e049SGordon Ross if (sr->session->signing.flags & SMB_SIGNING_ENABLED) {
587a90cf9f2SGordon Ross sr->session->signing.seqnum += 2;
588a90cf9f2SGordon Ross sr->sr_seqnum = sr->session->signing.seqnum;
589a90cf9f2SGordon Ross sr->reply_seqnum = sr->sr_seqnum + 1;
590a90cf9f2SGordon Ross }
591a90cf9f2SGordon Ross }
592a90cf9f2SGordon Ross
593a90cf9f2SGordon Ross /*
594a90cf9f2SGordon Ross * Submit the request to the task queue, which calls
595a90cf9f2SGordon Ross * smb1_tq_work when the workload permits.
596a90cf9f2SGordon Ross */
597a90cf9f2SGordon Ross sr->sr_time_submitted = gethrtime();
598a90cf9f2SGordon Ross sr->sr_state = SMB_REQ_STATE_SUBMITTED;
599a90cf9f2SGordon Ross smb_srqueue_waitq_enter(sr->session->s_srqueue);
600*9788d6deSGordon Ross tqid = taskq_dispatch(sr->sr_server->sv_worker_pool,
601a90cf9f2SGordon Ross smb1_tq_work, sr, TQ_SLEEP);
602*9788d6deSGordon Ross VERIFY(tqid != TASKQID_INVALID);
603a90cf9f2SGordon Ross
604a90cf9f2SGordon Ross return (0);
605a90cf9f2SGordon Ross }
606a90cf9f2SGordon Ross
607a90cf9f2SGordon Ross static void
smb1_tq_work(void * arg)608a90cf9f2SGordon Ross smb1_tq_work(void *arg)
609a90cf9f2SGordon Ross {
610a90cf9f2SGordon Ross smb_request_t *sr;
611a90cf9f2SGordon Ross smb_srqueue_t *srq;
612a90cf9f2SGordon Ross
613a90cf9f2SGordon Ross sr = (smb_request_t *)arg;
614a90cf9f2SGordon Ross SMB_REQ_VALID(sr);
615a90cf9f2SGordon Ross
616a90cf9f2SGordon Ross srq = sr->session->s_srqueue;
617a90cf9f2SGordon Ross smb_srqueue_waitq_to_runq(srq);
618a90cf9f2SGordon Ross sr->sr_worker = curthread;
619a90cf9f2SGordon Ross sr->sr_time_active = gethrtime();
620a90cf9f2SGordon Ross
621a90cf9f2SGordon Ross /*
6225677e049SGordon Ross * Always dispatch to the work function, because cancelled
6235677e049SGordon Ross * requests need an error reply (NT_STATUS_CANCELLED).
624a90cf9f2SGordon Ross */
6255677e049SGordon Ross mutex_enter(&sr->sr_mutex);
6265677e049SGordon Ross if (sr->sr_state == SMB_REQ_STATE_SUBMITTED)
6275677e049SGordon Ross sr->sr_state = SMB_REQ_STATE_ACTIVE;
628a90cf9f2SGordon Ross mutex_exit(&sr->sr_mutex);
6295677e049SGordon Ross
6305677e049SGordon Ross smb1sr_work(sr);
6315677e049SGordon Ross
632a90cf9f2SGordon Ross smb_srqueue_runq_exit(srq);
633a90cf9f2SGordon Ross }
634a90cf9f2SGordon Ross
635a90cf9f2SGordon Ross /*
636a90cf9f2SGordon Ross * smb1sr_work
637a90cf9f2SGordon Ross *
638a90cf9f2SGordon Ross * In most cases, this should free the request before return.
639a90cf9f2SGordon Ross * Exceptions are when a dispatch function returns SDRC_SR_KEPT.
640a90cf9f2SGordon Ross */
641a90cf9f2SGordon Ross void
smb1sr_work(struct smb_request * sr)642a90cf9f2SGordon Ross smb1sr_work(struct smb_request *sr)
643da6c28aaSamw {
6447b59d02dSjb150015 smb_sdrc_t sdrc;
6458622ec45SGordon Ross const smb_disp_entry_t *sdd;
6468622ec45SGordon Ross smb_disp_stats_t *sds;
6477b59d02dSjb150015 boolean_t disconnect = B_FALSE;
64859229f98Sjose borrego smb_session_t *session;
6498622ec45SGordon Ross smb_server_t *server;
6502c2961f8Sjose borrego uint32_t byte_count;
651584e0fceSGordon Ross uint32_t max_bytes;
652a90cf9f2SGordon Ross uint16_t pid_hi, pid_lo;
65359229f98Sjose borrego
65459229f98Sjose borrego session = sr->session;
6558622ec45SGordon Ross server = session->s_server;
656da6c28aaSamw
657da6c28aaSamw ASSERT(sr->tid_tree == 0);
658da6c28aaSamw ASSERT(sr->uid_user == 0);
659da6c28aaSamw ASSERT(sr->fid_ofile == 0);
660da6c28aaSamw sr->smb_fid = (uint16_t)-1;
661da6c28aaSamw
662da6c28aaSamw /* temporary until we identify a user */
6638622ec45SGordon Ross sr->user_cr = zone_kcred();
664da6c28aaSamw sr->orig_request_hdr = sr->command.chain_offset;
665da6c28aaSamw
666a90cf9f2SGordon Ross /*
667a90cf9f2SGordon Ross * Decode the SMB header.
668a90cf9f2SGordon Ross */
6693db3f65cSamw if (smb_mbc_decodef(&sr->command, SMB_HEADER_ED_FMT,
670da6c28aaSamw &sr->smb_com,
671da6c28aaSamw &sr->smb_rcls,
672da6c28aaSamw &sr->smb_reh,
673da6c28aaSamw &sr->smb_err,
674da6c28aaSamw &sr->smb_flg,
675da6c28aaSamw &sr->smb_flg2,
676a90cf9f2SGordon Ross &pid_hi,
677da6c28aaSamw sr->smb_sig,
678da6c28aaSamw &sr->smb_tid,
679a90cf9f2SGordon Ross &pid_lo,
680da6c28aaSamw &sr->smb_uid,
681da6c28aaSamw &sr->smb_mid) != 0) {
6827b59d02dSjb150015 disconnect = B_TRUE;
6837b59d02dSjb150015 goto drop_connection;
684da6c28aaSamw }
685a90cf9f2SGordon Ross sr->smb_pid = (pid_hi << 16) | pid_lo;
686da6c28aaSamw
687da6c28aaSamw /*
6887b59d02dSjb150015 * The reply "header" is filled in now even though it will,
6897b59d02dSjb150015 * most likely, be rewritten under reply_ready below. We
6907b59d02dSjb150015 * could reserve the space but this is convenient in case
6917b59d02dSjb150015 * the dialect dispatcher has to send a special reply (like
6927b59d02dSjb150015 * TRANSACT).
693da6c28aaSamw *
694da6c28aaSamw * Ensure that the 32-bit error code flag is turned off.
695da6c28aaSamw * Clients seem to set it in transact requests and they may
696da6c28aaSamw * get confused if we return success or a 16-bit SMB code.
697da6c28aaSamw */
698da6c28aaSamw sr->smb_rcls = 0;
699da6c28aaSamw sr->smb_reh = 0;
700da6c28aaSamw sr->smb_err = 0;
701da6c28aaSamw sr->smb_flg2 &= ~SMB_FLAGS2_NT_STATUS;
702da6c28aaSamw
7033db3f65cSamw (void) smb_mbc_encodef(&sr->reply, SMB_HEADER_ED_FMT,
704da6c28aaSamw sr->smb_com,
705da6c28aaSamw sr->smb_rcls,
706da6c28aaSamw sr->smb_reh,
707da6c28aaSamw sr->smb_err,
708da6c28aaSamw sr->smb_flg,
709da6c28aaSamw sr->smb_flg2,
710a90cf9f2SGordon Ross pid_hi,
711da6c28aaSamw sr->smb_sig,
712da6c28aaSamw sr->smb_tid,
713a90cf9f2SGordon Ross pid_lo,
714da6c28aaSamw sr->smb_uid,
715da6c28aaSamw sr->smb_mid);
716da6c28aaSamw sr->first_smb_com = sr->smb_com;
717da6c28aaSamw
7182a19195aSGordon Ross /* Need this for early goto report_error cases. */
7192a19195aSGordon Ross sr->cur_reply_offset = sr->reply.chain_offset;
7202a19195aSGordon Ross
721b819cea2SGordon Ross if ((session->signing.flags & SMB_SIGNING_CHECK) != 0) {
722b819cea2SGordon Ross if ((sr->smb_flg2 & SMB_FLAGS2_SMB_SECURITY_SIGNATURE) == 0 ||
723b819cea2SGordon Ross smb_sign_check_request(sr) != 0) {
7247b59d02dSjb150015 smbsr_error(sr, NT_STATUS_ACCESS_DENIED,
7257b59d02dSjb150015 ERRDOS, ERROR_ACCESS_DENIED);
7267b59d02dSjb150015 disconnect = B_TRUE;
7277b59d02dSjb150015 goto report_error;
728da6c28aaSamw }
729da6c28aaSamw }
730da6c28aaSamw
731da6c28aaSamw andx_more:
732148c5f43SAlan Wright sdd = &smb_disp_table[sr->smb_com];
733faa1795aSjb150015 ASSERT(sdd->sdt_function);
734a90cf9f2SGordon Ross sds = &server->sv_disp_stats1[sr->smb_com];
735da6c28aaSamw
7363db3f65cSamw if (smb_mbc_decodef(&sr->command, "b", &sr->smb_wct) != 0) {
7377b59d02dSjb150015 disconnect = B_TRUE;
7387b59d02dSjb150015 goto report_error;
739da6c28aaSamw }
740da6c28aaSamw
741da6c28aaSamw (void) MBC_SHADOW_CHAIN(&sr->smb_vwv, &sr->command,
742da6c28aaSamw sr->command.chain_offset, sr->smb_wct * 2);
743da6c28aaSamw
7443db3f65cSamw if (smb_mbc_decodef(&sr->command, "#.w", sr->smb_wct*2, &sr->smb_bcc)) {
7457b59d02dSjb150015 disconnect = B_TRUE;
7467b59d02dSjb150015 goto report_error;
747da6c28aaSamw }
748da6c28aaSamw
7498622ec45SGordon Ross atomic_add_64(&sds->sdt_rxb,
750148c5f43SAlan Wright (int64_t)(sr->smb_wct * 2 + sr->smb_bcc + 1));
751148c5f43SAlan Wright sr->sr_txb = sr->reply.chain_offset;
752148c5f43SAlan Wright
7532c2961f8Sjose borrego /*
7542c2961f8Sjose borrego * Ignore smb_bcc if CAP_LARGE_READX/CAP_LARGE_WRITEX
7552c2961f8Sjose borrego * and this is SmbReadX/SmbWriteX since this enables
7562c2961f8Sjose borrego * large reads/write and bcc is only 16-bits.
7572c2961f8Sjose borrego */
758584e0fceSGordon Ross max_bytes = sr->command.max_bytes - sr->command.chain_offset;
7591fb4a876SGordon Ross if (sr->smb_com == SMB_COM_WRITE_ANDX) {
7601fb4a876SGordon Ross /* Allow > BCC */
761584e0fceSGordon Ross byte_count = max_bytes;
762584e0fceSGordon Ross } else if (max_bytes < (uint32_t)sr->smb_bcc) {
763584e0fceSGordon Ross /* BCC is bogus. Will fail later. */
764584e0fceSGordon Ross byte_count = max_bytes;
7652c2961f8Sjose borrego } else {
766584e0fceSGordon Ross /* ordinary case */
7672c2961f8Sjose borrego byte_count = (uint32_t)sr->smb_bcc;
7682c2961f8Sjose borrego }
769da6c28aaSamw
7702c2961f8Sjose borrego (void) MBC_SHADOW_CHAIN(&sr->smb_data, &sr->command,
7712c2961f8Sjose borrego sr->command.chain_offset, byte_count);
7722c2961f8Sjose borrego
7732c2961f8Sjose borrego sr->command.chain_offset += byte_count;
774da6c28aaSamw if (sr->command.chain_offset > sr->command.max_bytes) {
7757b59d02dSjb150015 disconnect = B_TRUE;
7767b59d02dSjb150015 goto report_error;
777da6c28aaSamw }
778da6c28aaSamw
779da6c28aaSamw /* Store pointers for later */
780da6c28aaSamw sr->cur_reply_offset = sr->reply.chain_offset;
781da6c28aaSamw
782da6c28aaSamw if (is_andx_com(sr->smb_com)) {
783da6c28aaSamw /* Peek ahead and don't disturb vwv */
7843db3f65cSamw if (smb_mbc_peek(&sr->smb_vwv, sr->smb_vwv.chain_offset, "b.w",
785da6c28aaSamw &sr->andx_com, &sr->andx_off) < 0) {
7867b59d02dSjb150015 disconnect = B_TRUE;
7877b59d02dSjb150015 goto report_error;
788da6c28aaSamw }
789da6c28aaSamw } else {
790da6c28aaSamw sr->andx_com = (unsigned char)-1;
791da6c28aaSamw }
792da6c28aaSamw
793da6c28aaSamw mutex_enter(&sr->sr_mutex);
794da6c28aaSamw switch (sr->sr_state) {
7955677e049SGordon Ross case SMB_REQ_STATE_ACTIVE:
7965677e049SGordon Ross break;
797da6c28aaSamw case SMB_REQ_STATE_CLEANED_UP:
798da6c28aaSamw sr->sr_state = SMB_REQ_STATE_ACTIVE;
799da6c28aaSamw break;
8005677e049SGordon Ross case SMB_REQ_STATE_CANCELLED:
8015677e049SGordon Ross /*
8025677e049SGordon Ross * Keep cancelled. Handlers that might block will
8035677e049SGordon Ross * check the state and return NT_STATUS_CANCELLED.
8045677e049SGordon Ross */
805da6c28aaSamw break;
806da6c28aaSamw default:
807da6c28aaSamw ASSERT(0);
808da6c28aaSamw break;
809da6c28aaSamw }
810da6c28aaSamw mutex_exit(&sr->sr_mutex);
811da6c28aaSamw
812da6c28aaSamw /*
813da6c28aaSamw * Setup UID and TID information (if required). Both functions
814da6c28aaSamw * will set the sr credentials. In domain mode, the user and
815da6c28aaSamw * tree credentials should be the same. In share mode, the
816da6c28aaSamw * tree credentials (defined in the share definition) should
817da6c28aaSamw * override the user credentials.
818da6c28aaSamw */
819faa1795aSjb150015 if (!(sdd->sdt_flags & SDDF_SUPPRESS_UID) && (sr->uid_user == NULL)) {
8209fb67ea3Safshin salek ardakani - Sun Microsystems - Irvine United States sr->uid_user = smb_session_lookup_uid(session, sr->smb_uid);
821da6c28aaSamw if (sr->uid_user == NULL) {
822dc20a302Sas200622 smbsr_error(sr, 0, ERRSRV, ERRbaduid);
823faa1795aSjb150015 smbsr_cleanup(sr);
8247b59d02dSjb150015 goto report_error;
825da6c28aaSamw }
8267b59d02dSjb150015
827b89a8333Snatalie li - Sun Microsystems - Irvine United States sr->user_cr = smb_user_getcred(sr->uid_user);
8283b13a1efSThomas Keiser }
8293b13a1efSThomas Keiser if (!(sdd->sdt_flags & SDDF_SUPPRESS_TID) && (sr->tid_tree == NULL)) {
8303b13a1efSThomas Keiser sr->tid_tree = smb_session_lookup_tree(session, sr->smb_tid);
831da6c28aaSamw if (sr->tid_tree == NULL) {
832dc20a302Sas200622 smbsr_error(sr, 0, ERRSRV, ERRinvnid);
833faa1795aSjb150015 smbsr_cleanup(sr);
8347b59d02dSjb150015 goto report_error;
835da6c28aaSamw }
836da6c28aaSamw }
837da6c28aaSamw
838148c5f43SAlan Wright sr->sr_time_start = gethrtime();
839faa1795aSjb150015 if ((sdrc = (*sdd->sdt_pre_op)(sr)) == SDRC_SUCCESS)
840faa1795aSjb150015 sdrc = (*sdd->sdt_function)(sr);
841faa1795aSjb150015
842eb1d736bSafshin salek ardakani - Sun Microsystems - Irvine United States if (sdrc != SDRC_SR_KEPT) {
843148d1a41SMatt Barden (*sdd->sdt_post_op)(sr);
844eb1d736bSafshin salek ardakani - Sun Microsystems - Irvine United States smbsr_cleanup(sr);
845eb1d736bSafshin salek ardakani - Sun Microsystems - Irvine United States }
846ac2bf314SMatt Barden
847ac2bf314SMatt Barden smb_server_inc_req(server);
8488622ec45SGordon Ross smb_latency_add_sample(&sds->sdt_lat, gethrtime() - sr->sr_time_start);
849148c5f43SAlan Wright
8508622ec45SGordon Ross atomic_add_64(&sds->sdt_txb,
851148c5f43SAlan Wright (int64_t)(sr->reply.chain_offset - sr->sr_txb));
852eb1d736bSafshin salek ardakani - Sun Microsystems - Irvine United States
8537b59d02dSjb150015 switch (sdrc) {
854faa1795aSjb150015 case SDRC_SUCCESS:
855da6c28aaSamw break;
856da6c28aaSamw
857da6c28aaSamw case SDRC_DROP_VC:
8587b59d02dSjb150015 disconnect = B_TRUE;
8597b59d02dSjb150015 goto drop_connection;
860da6c28aaSamw
861da6c28aaSamw case SDRC_NO_REPLY:
862a90cf9f2SGordon Ross /* will free sr */
863a90cf9f2SGordon Ross goto out;
86459229f98Sjose borrego
86559229f98Sjose borrego case SDRC_SR_KEPT:
866a90cf9f2SGordon Ross /* Do NOT free sr */
867a90cf9f2SGordon Ross sr = NULL;
868a90cf9f2SGordon Ross goto out;
8697b59d02dSjb150015
870faa1795aSjb150015 case SDRC_ERROR:
8717b59d02dSjb150015 goto report_error;
872da6c28aaSamw
873faa1795aSjb150015 case SDRC_NOT_IMPLEMENTED:
874da6c28aaSamw default:
8757b59d02dSjb150015 smbsr_error(sr, 0, ERRDOS, ERRbadfunc);
8767b59d02dSjb150015 goto report_error;
877da6c28aaSamw }
878da6c28aaSamw
8797b59d02dSjb150015 /*
8807b59d02dSjb150015 * If there's no AndX command, we're done.
8817b59d02dSjb150015 */
882da6c28aaSamw if (sr->andx_com == 0xff)
883da6c28aaSamw goto reply_ready;
884da6c28aaSamw
8857b59d02dSjb150015 /*
8867b59d02dSjb150015 * Otherwise, we have to back-patch the AndXCommand and AndXOffset
8877b59d02dSjb150015 * and continue processing.
8887b59d02dSjb150015 */
889da6c28aaSamw sr->andx_prev_wct = sr->cur_reply_offset;
8903db3f65cSamw (void) smb_mbc_poke(&sr->reply, sr->andx_prev_wct + 1, "b.w",
891da6c28aaSamw sr->andx_com, MBC_LENGTH(&sr->reply));
892da6c28aaSamw
893da6c28aaSamw sr->command.chain_offset = sr->orig_request_hdr + sr->andx_off;
894da6c28aaSamw sr->smb_com = sr->andx_com;
895da6c28aaSamw goto andx_more;
896da6c28aaSamw
8977b59d02dSjb150015 report_error:
898da6c28aaSamw sr->reply.chain_offset = sr->cur_reply_offset;
8993db3f65cSamw (void) smb_mbc_encodef(&sr->reply, "bw", 0, 0);
900da6c28aaSamw
901da6c28aaSamw sr->smb_wct = 0;
902da6c28aaSamw sr->smb_bcc = 0;
903da6c28aaSamw
904faa1795aSjb150015 if (sr->smb_rcls == 0 && sr->smb_reh == 0 && sr->smb_err == 0)
9057b59d02dSjb150015 smbsr_error(sr, 0, ERRSRV, ERRerror);
9067b59d02dSjb150015
9077b59d02dSjb150015 reply_ready:
9087b59d02dSjb150015 smbsr_send_reply(sr);
9097b59d02dSjb150015
9107b59d02dSjb150015 drop_connection:
9111160dcf7SMatt Barden if (disconnect)
9121160dcf7SMatt Barden smb_session_disconnect(session);
91359229f98Sjose borrego
914a90cf9f2SGordon Ross out:
915a90cf9f2SGordon Ross if (sr != NULL) {
916a90cf9f2SGordon Ross mutex_enter(&sr->sr_mutex);
917a90cf9f2SGordon Ross sr->sr_state = SMB_REQ_STATE_COMPLETED;
918a90cf9f2SGordon Ross mutex_exit(&sr->sr_mutex);
919a90cf9f2SGordon Ross smb_request_free(sr);
920a90cf9f2SGordon Ross }
9217b59d02dSjb150015 }
922da6c28aaSamw
9237b59d02dSjb150015 int
smbsr_encode_empty_result(struct smb_request * sr)9247b59d02dSjb150015 smbsr_encode_empty_result(struct smb_request *sr)
9257b59d02dSjb150015 {
9267b59d02dSjb150015 return (smbsr_encode_result(sr, 0, 0, "bw", 0, 0));
9277b59d02dSjb150015 }
9287b59d02dSjb150015
9297b59d02dSjb150015 int
smbsr_encode_result(struct smb_request * sr,int wct,int bcc,const char * fmt,...)930a90cf9f2SGordon Ross smbsr_encode_result(struct smb_request *sr, int wct, int bcc,
931a90cf9f2SGordon Ross const char *fmt, ...)
932da6c28aaSamw {
933da6c28aaSamw va_list ap;
934da6c28aaSamw
9357b59d02dSjb150015 if (MBC_LENGTH(&sr->reply) != sr->cur_reply_offset)
9367b59d02dSjb150015 return (-1);
937da6c28aaSamw
938da6c28aaSamw va_start(ap, fmt);
9393db3f65cSamw (void) smb_mbc_vencodef(&sr->reply, fmt, ap);
940da6c28aaSamw va_end(ap);
941da6c28aaSamw
942da6c28aaSamw sr->smb_wct = (unsigned char)wct;
943da6c28aaSamw sr->smb_bcc = (uint16_t)bcc;
944da6c28aaSamw
9457b59d02dSjb150015 if (smbsr_check_result(sr, wct, bcc) != 0)
9467b59d02dSjb150015 return (-1);
9477b59d02dSjb150015
9487b59d02dSjb150015 return (0);
949da6c28aaSamw }
950da6c28aaSamw
9517b59d02dSjb150015 static int
smbsr_check_result(struct smb_request * sr,int wct,int bcc)952da6c28aaSamw smbsr_check_result(struct smb_request *sr, int wct, int bcc)
953da6c28aaSamw {
954da6c28aaSamw int offset = sr->cur_reply_offset;
955da6c28aaSamw int total_bytes;
956da6c28aaSamw unsigned char temp, temp1;
957da6c28aaSamw struct mbuf *m;
958da6c28aaSamw
959da6c28aaSamw total_bytes = 0;
960da6c28aaSamw m = sr->reply.chain;
961da6c28aaSamw while (m != 0) {
962da6c28aaSamw total_bytes += m->m_len;
963da6c28aaSamw m = m->m_next;
964da6c28aaSamw }
965da6c28aaSamw
9667b59d02dSjb150015 if ((offset + 3) > total_bytes)
9677b59d02dSjb150015 return (-1);
968da6c28aaSamw
9693db3f65cSamw (void) smb_mbc_peek(&sr->reply, offset, "b", &temp);
9707b59d02dSjb150015 if (temp != wct)
9717b59d02dSjb150015 return (-1);
972da6c28aaSamw
9737b59d02dSjb150015 if ((offset + (wct * 2 + 1)) > total_bytes)
9747b59d02dSjb150015 return (-1);
975da6c28aaSamw
976da6c28aaSamw /* reply wct & vwv seem ok, consider data now */
977da6c28aaSamw offset += wct * 2 + 1;
978da6c28aaSamw
9797b59d02dSjb150015 if ((offset + 2) > total_bytes)
9807b59d02dSjb150015 return (-1);
981da6c28aaSamw
9823db3f65cSamw (void) smb_mbc_peek(&sr->reply, offset, "bb", &temp, &temp1);
983da6c28aaSamw if (bcc == VAR_BCC) {
984da6c28aaSamw if ((temp != 0xFF) || (temp1 != 0xFF)) {
9857b59d02dSjb150015 return (-1);
986da6c28aaSamw } else {
987da6c28aaSamw bcc = (total_bytes - offset) - 2;
9883db3f65cSamw (void) smb_mbc_poke(&sr->reply, offset, "bb",
989da6c28aaSamw bcc, bcc >> 8);
990da6c28aaSamw }
991da6c28aaSamw } else {
9927b59d02dSjb150015 if ((temp != (bcc&0xFF)) || (temp1 != ((bcc>>8)&0xFF)))
9937b59d02dSjb150015 return (-1);
994da6c28aaSamw }
995da6c28aaSamw
996da6c28aaSamw offset += bcc + 2;
997da6c28aaSamw
9987b59d02dSjb150015 if (offset != total_bytes)
9997b59d02dSjb150015 return (-1);
1000da6c28aaSamw
1001da6c28aaSamw sr->smb_wct = (unsigned char)wct;
1002da6c28aaSamw sr->smb_bcc = (uint16_t)bcc;
10037b59d02dSjb150015 return (0);
1004da6c28aaSamw }
1005da6c28aaSamw
1006da6c28aaSamw int
smbsr_decode_vwv(struct smb_request * sr,const char * fmt,...)1007a90cf9f2SGordon Ross smbsr_decode_vwv(struct smb_request *sr, const char *fmt, ...)
1008da6c28aaSamw {
1009da6c28aaSamw int rc;
1010da6c28aaSamw va_list ap;
1011da6c28aaSamw
1012da6c28aaSamw va_start(ap, fmt);
10133db3f65cSamw rc = smb_mbc_vdecodef(&sr->smb_vwv, fmt, ap);
1014da6c28aaSamw va_end(ap);
1015da6c28aaSamw
1016faa1795aSjb150015 if (rc)
1017faa1795aSjb150015 smbsr_error(sr, 0, ERRSRV, ERRerror);
1018da6c28aaSamw return (rc);
1019da6c28aaSamw }
1020da6c28aaSamw
1021da6c28aaSamw int
smbsr_decode_data(struct smb_request * sr,const char * fmt,...)1022a90cf9f2SGordon Ross smbsr_decode_data(struct smb_request *sr, const char *fmt, ...)
1023da6c28aaSamw {
1024faa1795aSjb150015 int rc;
1025da6c28aaSamw va_list ap;
1026faa1795aSjb150015
1027da6c28aaSamw va_start(ap, fmt);
10283db3f65cSamw rc = smb_mbc_vdecodef(&sr->smb_data, fmt, ap);
1029da6c28aaSamw va_end(ap);
1030faa1795aSjb150015
1031faa1795aSjb150015 if (rc)
1032faa1795aSjb150015 smbsr_error(sr, 0, ERRSRV, ERRerror);
1033faa1795aSjb150015 return (rc);
1034da6c28aaSamw }
1035da6c28aaSamw
1036148c5f43SAlan Wright boolean_t
smbsr_decode_data_avail(smb_request_t * sr)1037148c5f43SAlan Wright smbsr_decode_data_avail(smb_request_t *sr)
1038148c5f43SAlan Wright {
1039148c5f43SAlan Wright return (sr->smb_data.chain_offset < sr->smb_data.max_bytes);
1040148c5f43SAlan Wright }
1041148c5f43SAlan Wright
1042da6c28aaSamw void
smbsr_send_reply(smb_request_t * sr)1043148c5f43SAlan Wright smbsr_send_reply(smb_request_t *sr)
1044da6c28aaSamw {
1045a90cf9f2SGordon Ross uint16_t pid_hi, pid_lo;
1046a90cf9f2SGordon Ross
1047c8ec8eeaSjose borrego if (SMB_TREE_IS_CASEINSENSITIVE(sr))
10487b59d02dSjb150015 sr->smb_flg |= SMB_FLAGS_CASE_INSENSITIVE;
10497b59d02dSjb150015 else
10507b59d02dSjb150015 sr->smb_flg &= ~SMB_FLAGS_CASE_INSENSITIVE;
1051a90cf9f2SGordon Ross pid_hi = sr->smb_pid >> 16;
1052a90cf9f2SGordon Ross pid_lo = (uint16_t)sr->smb_pid;
10537b59d02dSjb150015
10543db3f65cSamw (void) smb_mbc_poke(&sr->reply, 0, SMB_HEADER_ED_FMT,
1055da6c28aaSamw sr->first_smb_com,
1056da6c28aaSamw sr->smb_rcls,
1057da6c28aaSamw sr->smb_reh,
1058da6c28aaSamw sr->smb_err,
1059da6c28aaSamw sr->smb_flg | SMB_FLAGS_REPLY,
1060da6c28aaSamw sr->smb_flg2,
1061a90cf9f2SGordon Ross pid_hi,
1062da6c28aaSamw sr->smb_sig,
1063da6c28aaSamw sr->smb_tid,
1064a90cf9f2SGordon Ross pid_lo,
1065da6c28aaSamw sr->smb_uid,
1066da6c28aaSamw sr->smb_mid);
1067da6c28aaSamw
1068da6c28aaSamw if (sr->session->signing.flags & SMB_SIGNING_ENABLED)
1069da6c28aaSamw smb_sign_reply(sr, NULL);
1070da6c28aaSamw
10717b59d02dSjb150015 if (smb_session_send(sr->session, 0, &sr->reply) == 0)
10727b59d02dSjb150015 sr->reply.chain = 0;
1073da6c28aaSamw }
1074da6c28aaSamw
1075da6c28aaSamw void
smbsr_map_errno(int errnum,smb_error_t * err)1076dc20a302Sas200622 smbsr_map_errno(int errnum, smb_error_t *err)
1077da6c28aaSamw {
1078a90cf9f2SGordon Ross uint32_t status;
1079a90cf9f2SGordon Ross uint16_t doserr;
1080da6c28aaSamw
1081a90cf9f2SGordon Ross status = smb_errno2status(errnum);
1082a90cf9f2SGordon Ross doserr = smb_status2doserr(status);
1083da6c28aaSamw
1084a90cf9f2SGordon Ross err->status = status;
1085dc20a302Sas200622 err->errcls = ERRDOS;
1086a90cf9f2SGordon Ross err->errcode = doserr;
1087da6c28aaSamw }
1088da6c28aaSamw
1089da6c28aaSamw void
smbsr_errno(struct smb_request * sr,int errnum)1090dc20a302Sas200622 smbsr_errno(struct smb_request *sr, int errnum)
1091da6c28aaSamw {
10927b59d02dSjb150015 smbsr_map_errno(errnum, &sr->smb_error);
10937b59d02dSjb150015 smbsr_set_error(sr, &sr->smb_error);
1094da6c28aaSamw }
1095da6c28aaSamw
1096dc20a302Sas200622 /*
1097148c5f43SAlan Wright * Report a request processing status (error or warning).
1098dc20a302Sas200622 */
1099dc20a302Sas200622 void
smbsr_status(smb_request_t * sr,DWORD status,uint16_t errcls,uint16_t errcode)1100148c5f43SAlan Wright smbsr_status(smb_request_t *sr, DWORD status, uint16_t errcls, uint16_t errcode)
1101dc20a302Sas200622 {
1102a90cf9f2SGordon Ross
11037b59d02dSjb150015 sr->smb_error.status = status;
1104a90cf9f2SGordon Ross
1105a90cf9f2SGordon Ross /*
1106a90cf9f2SGordon Ross * This function is SMB1 specific. While adding SMB2 support,
1107a90cf9f2SGordon Ross * calls to this function have been removed from common code.
1108a90cf9f2SGordon Ross * In case we missed any, check for SMB2 callers here, and
1109a90cf9f2SGordon Ross * vector into a wrapper function that we can watch for...
1110a90cf9f2SGordon Ross * (and track down with dtrace:)
1111a90cf9f2SGordon Ross */
1112a90cf9f2SGordon Ross if (sr->session->dialect >= SMB_VERS_2_BASE) {
1113a90cf9f2SGordon Ross smbsr_status_smb2(sr, status);
1114a90cf9f2SGordon Ross return;
1115a90cf9f2SGordon Ross }
1116a90cf9f2SGordon Ross
1117a90cf9f2SGordon Ross if (status != 0 && errcls == 0 && errcode == 0) {
1118a90cf9f2SGordon Ross errcls = ERRDOS;
1119a90cf9f2SGordon Ross errcode = smb_status2doserr(status);
1120a90cf9f2SGordon Ross }
1121a90cf9f2SGordon Ross
11227b59d02dSjb150015 sr->smb_error.errcls = errcls;
11237b59d02dSjb150015 sr->smb_error.errcode = errcode;
1124dc20a302Sas200622
11257b59d02dSjb150015 smbsr_set_error(sr, &sr->smb_error);
1126dc20a302Sas200622 }
1127dc20a302Sas200622
1128dc20a302Sas200622 /*
1129dc20a302Sas200622 * Setup a request processing error. This function can be used to
1130dc20a302Sas200622 * report 32-bit status codes or DOS errors. Set the status code
1131dc20a302Sas200622 * to 0 (NT_STATUS_SUCCESS) to explicitly report a DOS error,
1132dc20a302Sas200622 * regardless of the client capabilities.
1133dc20a302Sas200622 *
1134dc20a302Sas200622 * If status is non-zero and the client supports 32-bit status
1135dc20a302Sas200622 * codes, report the status. Otherwise, report the DOS error.
1136dc20a302Sas200622 */
1137dc20a302Sas200622 void
smbsr_set_error(smb_request_t * sr,smb_error_t * err)1138dc20a302Sas200622 smbsr_set_error(smb_request_t *sr, smb_error_t *err)
1139dc20a302Sas200622 {
1140dc20a302Sas200622 uint32_t status;
1141dc20a302Sas200622 uint32_t capabilities;
1142dc20a302Sas200622
1143dc20a302Sas200622 ASSERT(sr);
1144dc20a302Sas200622 ASSERT(err);
1145dc20a302Sas200622
1146dc20a302Sas200622 status = err->status;
1147dc20a302Sas200622 capabilities = sr->session->capabilities;
1148dc20a302Sas200622
1149dc20a302Sas200622 if ((err->errcls == 0) && (err->errcode == 0)) {
1150dc20a302Sas200622 capabilities |= CAP_STATUS32;
1151dc20a302Sas200622 if (status == 0)
1152dc20a302Sas200622 status = NT_STATUS_INTERNAL_ERROR;
1153dc20a302Sas200622 }
1154dc20a302Sas200622
1155dc20a302Sas200622 if ((capabilities & CAP_STATUS32) && (status != 0)) {
1156dc20a302Sas200622 sr->smb_rcls = status & 0xff;
1157dc20a302Sas200622 sr->smb_reh = (status >> 8) & 0xff;
1158dc20a302Sas200622 sr->smb_err = status >> 16;
1159dc20a302Sas200622 sr->smb_flg2 |= SMB_FLAGS2_NT_STATUS;
1160dc20a302Sas200622 } else {
1161dc20a302Sas200622 if ((err->errcls == 0) || (err->errcode == 0)) {
1162dc20a302Sas200622 sr->smb_rcls = ERRSRV;
1163dc20a302Sas200622 sr->smb_err = ERRerror;
1164dc20a302Sas200622 } else {
1165dc20a302Sas200622 sr->smb_rcls = (uint8_t)err->errcls;
1166dc20a302Sas200622 sr->smb_err = (uint16_t)err->errcode;
1167dc20a302Sas200622 }
1168dc20a302Sas200622 }
1169da6c28aaSamw }
1170da6c28aaSamw
1171da6c28aaSamw smb_xa_t *
smbsr_lookup_xa(smb_request_t * sr)1172da6c28aaSamw smbsr_lookup_xa(smb_request_t *sr)
1173da6c28aaSamw {
1174da6c28aaSamw ASSERT(sr->r_xa == 0);
1175da6c28aaSamw
1176da6c28aaSamw sr->r_xa = smb_xa_find(sr->session, sr->smb_pid, sr->smb_mid);
1177da6c28aaSamw return (sr->r_xa);
1178da6c28aaSamw }
1179da6c28aaSamw
1180da6c28aaSamw void
smbsr_release_file(smb_request_t * sr)1181e3f2c991SKeyur Desai smbsr_release_file(smb_request_t *sr)
1182da6c28aaSamw {
1183da6c28aaSamw smb_ofile_t *of = sr->fid_ofile;
1184da6c28aaSamw
1185da6c28aaSamw sr->fid_ofile = NULL;
1186da6c28aaSamw (void) smb_ofile_release(of);
1187da6c28aaSamw }
1188da6c28aaSamw
11892c2961f8Sjose borrego void
smbsr_lookup_file(smb_request_t * sr)11902c2961f8Sjose borrego smbsr_lookup_file(smb_request_t *sr)
11912c2961f8Sjose borrego {
11922c2961f8Sjose borrego if (sr->fid_ofile == NULL)
11933b13a1efSThomas Keiser sr->fid_ofile = smb_ofile_lookup_by_fid(sr, sr->smb_fid);
11942c2961f8Sjose borrego }
11952c2961f8Sjose borrego
1196da6c28aaSamw static int
is_andx_com(unsigned char com)1197da6c28aaSamw is_andx_com(unsigned char com)
1198da6c28aaSamw {
1199da6c28aaSamw switch (com) {
1200da6c28aaSamw case SMB_COM_LOCKING_ANDX:
1201da6c28aaSamw case SMB_COM_OPEN_ANDX:
1202da6c28aaSamw case SMB_COM_READ_ANDX:
1203da6c28aaSamw case SMB_COM_WRITE_ANDX:
1204da6c28aaSamw case SMB_COM_SESSION_SETUP_ANDX:
1205da6c28aaSamw case SMB_COM_LOGOFF_ANDX:
1206da6c28aaSamw case SMB_COM_TREE_CONNECT_ANDX:
1207da6c28aaSamw case SMB_COM_NT_CREATE_ANDX:
1208da6c28aaSamw return (1);
1209da6c28aaSamw }
1210da6c28aaSamw return (0);
1211da6c28aaSamw }
1212da6c28aaSamw
1213da6c28aaSamw /*
1214faa1795aSjb150015 * Invalid command stubs.
1215faa1795aSjb150015 *
1216faa1795aSjb150015 * The Read/Write Block Multiplexed (mpx) protocol is used to maximize
1217faa1795aSjb150015 * performance when reading/writing a large block of data: it can be
1218faa1795aSjb150015 * used in parallel with other client/server operations. The mpx sub-
1219faa1795aSjb150015 * protocol is not supported because we support only connection oriented
1220faa1795aSjb150015 * transports and NT supports mpx only over connectionless transports.
1221da6c28aaSamw */
12227b59d02dSjb150015 smb_sdrc_t
smb_pre_invalid(smb_request_t * sr)1223faa1795aSjb150015 smb_pre_invalid(smb_request_t *sr)
1224da6c28aaSamw {
122593bc28dbSGordon Ross DTRACE_SMB_START(op__Invalid, smb_request_t *, sr);
1226faa1795aSjb150015 return (SDRC_SUCCESS);
1227faa1795aSjb150015 }
1228faa1795aSjb150015
1229faa1795aSjb150015 void
smb_post_invalid(smb_request_t * sr)1230faa1795aSjb150015 smb_post_invalid(smb_request_t *sr)
1231faa1795aSjb150015 {
123293bc28dbSGordon Ross DTRACE_SMB_DONE(op__Invalid, smb_request_t *, sr);
1233faa1795aSjb150015 }
1234faa1795aSjb150015
1235faa1795aSjb150015 smb_sdrc_t
smb_com_invalid(smb_request_t * sr)1236faa1795aSjb150015 smb_com_invalid(smb_request_t *sr)
1237faa1795aSjb150015 {
1238faa1795aSjb150015 smb_sdrc_t sdrc;
1239faa1795aSjb150015
1240faa1795aSjb150015 switch (sr->smb_com) {
1241faa1795aSjb150015 case SMB_COM_WRITE_COMPLETE:
1242faa1795aSjb150015 smbsr_error(sr, 0, ERRSRV, ERRerror);
1243faa1795aSjb150015 sdrc = SDRC_ERROR;
1244faa1795aSjb150015 break;
1245faa1795aSjb150015
1246faa1795aSjb150015 default:
1247faa1795aSjb150015 smbsr_error(sr, NT_STATUS_NOT_IMPLEMENTED,
1248faa1795aSjb150015 ERRDOS, ERROR_INVALID_FUNCTION);
1249faa1795aSjb150015 sdrc = SDRC_NOT_IMPLEMENTED;
1250faa1795aSjb150015 break;
1251faa1795aSjb150015 }
1252faa1795aSjb150015
1253faa1795aSjb150015 return (sdrc);
1254da6c28aaSamw }
1255da6c28aaSamw
1256da6c28aaSamw /*
1257148c5f43SAlan Wright * smb_dispatch_stats_init
1258da6c28aaSamw *
1259148c5f43SAlan Wright * Initializes dispatch statistics.
1260da6c28aaSamw */
1261da6c28aaSamw void
smb_dispatch_stats_init(smb_server_t * sv)12628622ec45SGordon Ross smb_dispatch_stats_init(smb_server_t *sv)
1263da6c28aaSamw {
1264a90cf9f2SGordon Ross smb_disp_stats_t *sds = sv->sv_disp_stats1;
12658622ec45SGordon Ross smb_kstat_req_t *ksr;
1266faa1795aSjb150015 int i;
1267da6c28aaSamw
1268a90cf9f2SGordon Ross ksr = ((smbsrv_kstats_t *)sv->sv_ksp->ks_data)->ks_reqs1;
12698622ec45SGordon Ross
1270148c5f43SAlan Wright for (i = 0; i < SMB_COM_NUM; i++, ksr++) {
12718622ec45SGordon Ross smb_latency_init(&sds[i].sdt_lat);
1272148c5f43SAlan Wright (void) strlcpy(ksr->kr_name, smb_disp_table[i].sdt_name,
1273148c5f43SAlan Wright sizeof (ksr->kr_name));
1274da6c28aaSamw }
1275da6c28aaSamw }
1276da6c28aaSamw
1277da6c28aaSamw /*
1278148c5f43SAlan Wright * smb_dispatch_stats_fini
1279da6c28aaSamw *
1280148c5f43SAlan Wright * Frees and destroyes the resources used for statistics.
1281da6c28aaSamw */
1282da6c28aaSamw void
smb_dispatch_stats_fini(smb_server_t * sv)12838622ec45SGordon Ross smb_dispatch_stats_fini(smb_server_t *sv)
1284da6c28aaSamw {
1285a90cf9f2SGordon Ross smb_disp_stats_t *sds = sv->sv_disp_stats1;
1286148c5f43SAlan Wright int i;
1287148c5f43SAlan Wright
1288148c5f43SAlan Wright for (i = 0; i < SMB_COM_NUM; i++)
12898622ec45SGordon Ross smb_latency_destroy(&sds[i].sdt_lat);
1290148c5f43SAlan Wright }
1291148c5f43SAlan Wright
1292148c5f43SAlan Wright void
smb_dispatch_stats_update(smb_server_t * sv,smb_kstat_req_t * ksr,int first,int nreq)12938622ec45SGordon Ross smb_dispatch_stats_update(smb_server_t *sv,
12948622ec45SGordon Ross smb_kstat_req_t *ksr, int first, int nreq)
1295148c5f43SAlan Wright {
1296a90cf9f2SGordon Ross smb_disp_stats_t *sds = sv->sv_disp_stats1;
1297148c5f43SAlan Wright int i;
1298148c5f43SAlan Wright int last;
1299148c5f43SAlan Wright
1300148c5f43SAlan Wright last = first + nreq - 1;
1301148c5f43SAlan Wright
1302148c5f43SAlan Wright if ((first < SMB_COM_NUM) && (last < SMB_COM_NUM)) {
1303148c5f43SAlan Wright for (i = first; i <= last; i++, ksr++) {
13048622ec45SGordon Ross ksr->kr_rxb = sds[i].sdt_rxb;
13058622ec45SGordon Ross ksr->kr_txb = sds[i].sdt_txb;
13068622ec45SGordon Ross mutex_enter(&sds[i].sdt_lat.ly_mutex);
13078622ec45SGordon Ross ksr->kr_nreq = sds[i].sdt_lat.ly_a_nreq;
13088622ec45SGordon Ross ksr->kr_sum = sds[i].sdt_lat.ly_a_sum;
13098622ec45SGordon Ross ksr->kr_a_mean = sds[i].sdt_lat.ly_a_mean;
1310148c5f43SAlan Wright ksr->kr_a_stddev =
13118622ec45SGordon Ross sds[i].sdt_lat.ly_a_stddev;
13128622ec45SGordon Ross ksr->kr_d_mean = sds[i].sdt_lat.ly_d_mean;
1313148c5f43SAlan Wright ksr->kr_d_stddev =
13148622ec45SGordon Ross sds[i].sdt_lat.ly_d_stddev;
13158622ec45SGordon Ross sds[i].sdt_lat.ly_d_mean = 0;
13168622ec45SGordon Ross sds[i].sdt_lat.ly_d_nreq = 0;
13178622ec45SGordon Ross sds[i].sdt_lat.ly_d_stddev = 0;
13188622ec45SGordon Ross sds[i].sdt_lat.ly_d_sum = 0;
13198622ec45SGordon Ross mutex_exit(&sds[i].sdt_lat.ly_mutex);
1320148c5f43SAlan Wright }
1321da6c28aaSamw }
1322da6c28aaSamw }
1323