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 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * SMB requests. 28 * 29 * Request 30 * Header 31 * Magic 0xFF 'S' 'M' 'B' 32 * smb_com a byte, the "first" command 33 * Error a 4-byte union, ignored in a request 34 * smb_flg a one byte set of eight flags 35 * smb_flg2 a two byte set of 16 flags 36 * . twelve reserved bytes, have a role 37 * in connectionless transports (IPX, UDP?) 38 * smb_tid a 16-bit tree ID, a mount point sorta, 39 * 0xFFFF is this command does not have 40 * or require a tree context 41 * smb_pid a 16-bit process ID 42 * smb_uid a 16-bit user ID, specific to this "session" 43 * and mapped to a system (bona-fide) UID 44 * smb_mid a 16-bit multiplex ID, used to differentiate 45 * multiple simultaneous requests from the same 46 * process (pid) (ref RPC "xid") 47 * 48 * Chained (AndX) commands (0 or more) 49 * smb_wct a byte, number of 16-bit words containing 50 * command parameters, min 2 for chained command 51 * andx_com a byte, the "next" command, 0xFF for none 52 * . an unused byte 53 * andx_off a 16-bit offset, byte displacement from &Magic 54 * to the smb_wct field of the "next" command, 55 * ignore if andx_com is 0xFF, s/b 0 if no next 56 * smb_vwv[] 0 or more 16-bit (sorta) parameters for 57 * "this" command (i.e. smb_com if this is the 58 * first parameters, or the andx_com of the just 59 * previous block. 60 * smb_bcc a 16-bit count of smb_data[] bytes 61 * smb_data[] 0 or more bytes, format specific to commands 62 * padding[] Optional padding 63 * 64 * Last command 65 * smb_wct a byte, number of 16-bit words containing 66 * command parameters, min 0 for chained command 67 * smb_vwv[] 0 or more 16-bit (sorta) parameters for 68 * "this" command (i.e. smb_com if this is the 69 * first parameters, or the andx_com of the just 70 * previous block. 71 * smb_bcc a 16-bit count of smb_data[] bytes 72 * smb_data[] 0 or more bytes, format specific to commands 73 * 74 * Reply 75 * Header 76 * Magic 0xFF 'S' 'M' 'B' 77 * smb_com a byte, the "first" command, corresponds 78 * to request 79 * Error a 4-byte union, coding depends on dialect in use 80 * for "DOS" errors 81 * a byte for error class 82 * an unused byte 83 * a 16-bit word for error code 84 * for "NT" errors 85 * a 32-bit error code which 86 * is a packed class and specifier 87 * for "OS/2" errors 88 * I don't know 89 * The error information is specific to the 90 * last command in the reply chain. 91 * smb_flg a one byte set of eight flags, 0x80 bit set 92 * indicating this message is a reply 93 * smb_flg2 a two byte set of 16 flags 94 * . twelve reserved bytes, have a role 95 * in connectionless transports (IPX, UDP?) 96 * smb_tid a 16-bit tree ID, a mount point sorta, 97 * should be the same as the request 98 * smb_pid a 16-bit process ID, MUST BE the same as request 99 * smb_uid a 16-bit user ID, specific to this "session" 100 * and mapped to a system (bona-fide) UID, 101 * should be the same as request 102 * smb_mid a 16-bit multiplex ID, used to differentiate 103 * multiple simultaneous requests from the same 104 * process (pid) (ref RPC "xid"), MUST BE the 105 * same as request 106 * padding[] Optional padding 107 * 108 * Chained (AndX) commands (0 or more) 109 * smb_wct a byte, number of 16-bit words containing 110 * command parameters, min 2 for chained command, 111 * andx_com a byte, the "next" command, 0xFF for none, 112 * corresponds to request, if this is the chained 113 * command that had an error set to 0xFF 114 * . an unused byte 115 * andx_off a 16-bit offset, byte displacement from &Magic 116 * to the smb_wct field of the "next" command, 117 * ignore if andx_com is 0xFF, s/b 0 if no next 118 * smb_vwv[] 0 or more 16-bit (sorta) parameters for 119 * "this" command (i.e. smb_com if this is the 120 * first parameters, or the andx_com of the just 121 * previous block. Empty if an error. 122 * smb_bcc a 16-bit count of smb_data[] bytes 123 * smb_data[] 0 or more bytes, format specific to commands 124 * empty if an error. 125 * 126 * Last command 127 * smb_wct a byte, number of 16-bit words containing 128 * command parameters, min 0 for chained command 129 * smb_vwv[] 0 or more 16-bit (sorta) parameters for 130 * "this" command (i.e. smb_com if this is the 131 * first parameters, or the andx_com of the just 132 * previous block, empty if an error. 133 * smb_bcc a 16-bit count of smb_data[] bytes 134 * smb_data[] 0 or more bytes, format specific to commands, 135 * empty if an error. 136 */ 137 138 #include <smbsrv/smb_incl.h> 139 #include <smbsrv/smb_kstat.h> 140 #include <sys/sdt.h> 141 142 #define SMB_ALL_DISPATCH_STAT_INCR(stat) atomic_inc_64(&stat); 143 #define SMB_COM_NUM 256 144 145 static kstat_t *smb_dispatch_ksp = NULL; 146 static kmutex_t smb_dispatch_ksmtx; 147 148 static int is_andx_com(unsigned char); 149 static int smbsr_check_result(struct smb_request *, int, int); 150 151 static smb_disp_entry_t dispatch[SMB_COM_NUM] = { 152 { SMB_SDT_OPS(create_directory), /* 0x00 000 */ 153 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 154 { "SmbCreateDirectory", KSTAT_DATA_UINT64 } }, 155 { SMB_SDT_OPS(delete_directory), /* 0x01 001 */ 156 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 157 { "SmbDeleteDirectory", KSTAT_DATA_UINT64 } }, 158 { SMB_SDT_OPS(open), /* 0x02 002 */ 159 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 160 { "SmbOpen", KSTAT_DATA_UINT64 } }, 161 { SMB_SDT_OPS(create), /* 0x03 003 */ 162 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 163 { "SmbCreate", KSTAT_DATA_UINT64 } }, 164 { SMB_SDT_OPS(close), /* 0x04 004 */ 165 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 166 { "SmbClose", KSTAT_DATA_UINT64 } }, 167 { SMB_SDT_OPS(flush), /* 0x05 005 */ 168 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 169 { "SmbFlush", KSTAT_DATA_UINT64 } }, 170 { SMB_SDT_OPS(delete), /* 0x06 006 */ 171 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 172 { "SmbDelete", KSTAT_DATA_UINT64 } }, 173 { SMB_SDT_OPS(rename), /* 0x07 007 */ 174 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 175 { "SmbRename", KSTAT_DATA_UINT64 } }, 176 { SMB_SDT_OPS(query_information), /* 0x08 008 */ 177 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 178 { "SmbQueryInformation", KSTAT_DATA_UINT64 } }, 179 { SMB_SDT_OPS(set_information), /* 0x09 009 */ 180 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 181 { "SmbSetInformation", KSTAT_DATA_UINT64 } }, 182 { SMB_SDT_OPS(read), /* 0x0A 010 */ 183 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 184 { "SmbRead", KSTAT_DATA_UINT64 } }, 185 { SMB_SDT_OPS(write), /* 0x0B 011 */ 186 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 187 { "SmbWrite", KSTAT_DATA_UINT64 } }, 188 { SMB_SDT_OPS(lock_byte_range), /* 0x0C 012 */ 189 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 190 { "SmbLockByteRange", KSTAT_DATA_UINT64 } }, 191 { SMB_SDT_OPS(unlock_byte_range), /* 0x0D 013 */ 192 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 193 { "SmbUnlockByteRange", KSTAT_DATA_UINT64 } }, 194 { SMB_SDT_OPS(create_temporary), /* 0x0E 014 */ 195 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 196 { "SmbCreateTemporary", KSTAT_DATA_UINT64 } }, 197 { SMB_SDT_OPS(create_new), /* 0x0F 015 */ 198 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 199 { "SmbCreateNew", KSTAT_DATA_UINT64 } }, 200 { SMB_SDT_OPS(check_directory), /* 0x10 016 */ 201 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 202 { "SmbCheckDirectory", KSTAT_DATA_UINT64 } }, 203 { SMB_SDT_OPS(process_exit), /* 0x11 017 */ 204 PC_NETWORK_PROGRAM_1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID, 205 RW_READER, 206 { "SmbProcessExit", KSTAT_DATA_UINT64 } }, 207 { SMB_SDT_OPS(seek), /* 0x12 018 */ 208 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 209 { "SmbSeek", KSTAT_DATA_UINT64 } }, 210 { SMB_SDT_OPS(lock_and_read), /* 0x13 019 */ 211 LANMAN1_0, 0, RW_READER, 212 { "SmbLockAndRead", KSTAT_DATA_UINT64 } }, 213 { SMB_SDT_OPS(write_and_unlock), /* 0x14 020 */ 214 LANMAN1_0, 0, RW_READER, 215 { "SmbWriteAndUnlock", KSTAT_DATA_UINT64 } }, 216 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x15 021 */ 217 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x16 022 */ 218 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x17 023 */ 219 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x18 024 */ 220 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x19 025 */ 221 { SMB_SDT_OPS(read_raw), /* 0x1A 026 */ 222 LANMAN1_0, 0, RW_WRITER, 223 { "SmbReadRaw", KSTAT_DATA_UINT64 } }, 224 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x1B 027 */ 225 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x1C 028 */ 226 { SMB_SDT_OPS(write_raw), /* 0x1D 029 */ 227 LANMAN1_0, 0, RW_WRITER, 228 { "SmbWriteRaw", KSTAT_DATA_UINT64 } }, 229 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x1E 030 */ 230 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x1F 031 */ 231 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x20 032 */ 232 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x21 033 */ 233 { SMB_SDT_OPS(set_information2), /* 0x22 034 */ 234 LANMAN1_0, 0, RW_READER, 235 { "SmbSetInformation2", KSTAT_DATA_UINT64 } }, 236 { SMB_SDT_OPS(query_information2), /* 0x23 035 */ 237 LANMAN1_0, 0, RW_READER, 238 { "SmbQueryInformation2", KSTAT_DATA_UINT64 } }, 239 { SMB_SDT_OPS(locking_andx), /* 0x24 036 */ 240 LANMAN1_0, 0, RW_READER, 241 { "SmbLockingX", KSTAT_DATA_UINT64 } }, 242 { SMB_SDT_OPS(transaction), /* 0x25 037 */ 243 LANMAN1_0, 0, RW_READER, 244 { "SmbTransaction", KSTAT_DATA_UINT64 } }, 245 { SMB_SDT_OPS(transaction_secondary), /* 0x26 038 */ 246 LANMAN1_0, 0, RW_READER, 247 { "SmbTransactionSecondary", KSTAT_DATA_UINT64 } }, 248 { SMB_SDT_OPS(ioctl), /* 0x27 039 */ 249 LANMAN1_0, 0, RW_READER, 250 { "SmbIoctl", KSTAT_DATA_UINT64 } }, 251 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x28 040 */ 252 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x29 041 */ 253 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x2A 042 */ 254 { SMB_SDT_OPS(echo), /* 0x2B 043 */ 255 LANMAN1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID, 256 RW_READER, 257 { "SmbEcho", KSTAT_DATA_UINT64 } }, 258 { SMB_SDT_OPS(write_and_close), /* 0x2C 044 */ 259 LANMAN1_0, 0, RW_READER, 260 { "SmbWriteAndClose", KSTAT_DATA_UINT64 } }, 261 { SMB_SDT_OPS(open_andx), /* 0x2D 045 */ 262 LANMAN1_0, 0, RW_READER, 263 { "SmbOpenX", KSTAT_DATA_UINT64 } }, 264 { SMB_SDT_OPS(read_andx), /* 0x2E 046 */ 265 LANMAN1_0, 0, RW_READER, 266 { "SmbReadX", KSTAT_DATA_UINT64 } }, 267 { SMB_SDT_OPS(write_andx), /* 0x2F 047 */ 268 LANMAN1_0, 0, RW_READER, 269 { "SmbWriteX", KSTAT_DATA_UINT64 } }, 270 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x30 048 */ 271 { SMB_SDT_OPS(close_and_tree_disconnect), /* 0x31 049 */ 272 LANMAN1_0, 0, RW_READER, 273 { "SmbCloseAndTreeDisconnect", KSTAT_DATA_UINT64 } }, 274 { SMB_SDT_OPS(transaction2), /* 0x32 050 */ 275 LM1_2X002, 0, RW_READER, 276 { "SmbTransaction2", KSTAT_DATA_UINT64 } }, 277 { SMB_SDT_OPS(transaction2_secondary), /* 0x33 051 */ 278 LM1_2X002, 0, RW_READER, 279 { "SmbTransaction2Secondary", KSTAT_DATA_UINT64 } }, 280 { SMB_SDT_OPS(find_close2), /* 0x34 052 */ 281 LM1_2X002, 0, RW_READER, 282 { "SmbFindClose2", KSTAT_DATA_UINT64 } }, 283 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x35 053 */ 284 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x36 054 */ 285 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x37 055 */ 286 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x38 056 */ 287 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x39 057 */ 288 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3A 058 */ 289 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3B 059 */ 290 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3C 060 */ 291 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3D 061 */ 292 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3E 062 */ 293 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x3F 063 */ 294 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x40 064 */ 295 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x41 065 */ 296 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x42 066 */ 297 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x43 067 */ 298 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x44 068 */ 299 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x45 069 */ 300 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x46 070 */ 301 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x47 071 */ 302 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x48 072 */ 303 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x49 073 */ 304 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4A 074 */ 305 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4B 075 */ 306 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4C 076 */ 307 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4D 077 */ 308 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4E 078 */ 309 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x4F 079 */ 310 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x50 080 */ 311 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x51 081 */ 312 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x52 082 */ 313 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x53 083 */ 314 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x54 084 */ 315 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x55 085 */ 316 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x56 086 */ 317 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x57 087 */ 318 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x58 088 */ 319 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x59 089 */ 320 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5A 090 */ 321 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5B 091 */ 322 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5C 092 */ 323 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5D 093 */ 324 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5E 094 */ 325 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x5F 095 */ 326 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x60 096 */ 327 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x61 097 */ 328 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x62 098 */ 329 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x63 099 */ 330 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x64 100 */ 331 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x65 101 */ 332 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x66 102 */ 333 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x67 103 */ 334 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x68 104 */ 335 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x69 105 */ 336 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6A 106 */ 337 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6B 107 */ 338 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6C 108 */ 339 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6D 109 */ 340 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6E 110 */ 341 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x6F 111 */ 342 { SMB_SDT_OPS(tree_connect), /* 0x70 112 */ 343 PC_NETWORK_PROGRAM_1_0, SDDF_SUPPRESS_TID, RW_READER, 344 { "SmbTreeConnect", KSTAT_DATA_UINT64 } }, 345 { SMB_SDT_OPS(tree_disconnect), /* 0x71 113 */ 346 PC_NETWORK_PROGRAM_1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID, 347 RW_READER, 348 { "SmbTreeDisconnect", KSTAT_DATA_UINT64 } }, 349 { SMB_SDT_OPS(negotiate), /* 0x72 114 */ 350 PC_NETWORK_PROGRAM_1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID, 351 RW_WRITER, 352 { "SmbNegotiate", KSTAT_DATA_UINT64 } }, 353 { SMB_SDT_OPS(session_setup_andx), /* 0x73 115 */ 354 LANMAN1_0, SDDF_SUPPRESS_TID | SDDF_SUPPRESS_UID, 355 RW_READER, 356 { "SmbSessionSetupX", KSTAT_DATA_UINT64 } }, 357 { SMB_SDT_OPS(logoff_andx), /* 0x74 116 */ 358 LM1_2X002, SDDF_SUPPRESS_TID, RW_READER, 359 { "SmbLogoffX", KSTAT_DATA_UINT64 } }, 360 { SMB_SDT_OPS(tree_connect_andx), /* 0x75 117 */ 361 LANMAN1_0, SDDF_SUPPRESS_TID, RW_READER, 362 { "SmbTreeConnectX", KSTAT_DATA_UINT64 } }, 363 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x76 118 */ 364 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x77 119 */ 365 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x78 120 */ 366 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x79 121 */ 367 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7A 122 */ 368 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7B 123 */ 369 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7C 124 */ 370 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7D 125 */ 371 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7E 126 */ 372 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x7F 127 */ 373 { SMB_SDT_OPS(query_information_disk), /* 0x80 128 */ 374 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 375 { "SmbQueryInformationDisk", KSTAT_DATA_UINT64 } }, 376 { SMB_SDT_OPS(search), /* 0x81 129 */ 377 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 378 { "SmbSearch", KSTAT_DATA_UINT64 } }, 379 { SMB_SDT_OPS(find), /* 0x82 130 */ 380 LANMAN1_0, 0, RW_READER, 381 { "SmbFind", KSTAT_DATA_UINT64 } }, 382 { SMB_SDT_OPS(find_unique), /* 0x83 131 */ 383 LANMAN1_0, 0, RW_READER, 384 { "SmbFindUnique", KSTAT_DATA_UINT64 } }, 385 { SMB_SDT_OPS(find_close), /* 0x84 132 */ 386 LANMAN1_0, 0, RW_READER, 387 { "SmbFindClose", KSTAT_DATA_UINT64 } }, 388 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x85 133 */ 389 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x86 134 */ 390 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x87 135 */ 391 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x88 136 */ 392 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x89 137 */ 393 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8A 138 */ 394 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8B 139 */ 395 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8C 140 */ 396 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8D 141 */ 397 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8E 142 */ 398 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x8F 143 */ 399 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x90 144 */ 400 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x91 145 */ 401 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x92 146 */ 402 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x93 147 */ 403 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x94 148 */ 404 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x95 149 */ 405 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x96 150 */ 406 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x97 151 */ 407 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x98 152 */ 408 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x99 153 */ 409 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9A 154 */ 410 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9B 155 */ 411 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9C 156 */ 412 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9D 157 */ 413 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9E 158 */ 414 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0x9F 159 */ 415 { SMB_SDT_OPS(nt_transact), /* 0xA0 160 */ 416 NT_LM_0_12, 0, RW_READER, 417 { "SmbNtTransact", KSTAT_DATA_UINT64 } }, 418 { SMB_SDT_OPS(nt_transact_secondary), /* 0xA1 161 */ 419 NT_LM_0_12, 0, RW_READER, 420 { "SmbNtTransactSecondary", KSTAT_DATA_UINT64 } }, 421 { SMB_SDT_OPS(nt_create_andx), /* 0xA2 162 */ 422 NT_LM_0_12, 0, RW_READER, 423 { "SmbNtCreateX", KSTAT_DATA_UINT64 } }, 424 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA3 163 */ 425 { SMB_SDT_OPS(nt_cancel), /* 0xA4 164 */ 426 NT_LM_0_12, 0, RW_READER, 427 { "SmbNtCancel", KSTAT_DATA_UINT64 } }, 428 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA5 165 */ 429 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA6 166 */ 430 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA7 167 */ 431 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA8 168 */ 432 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xA9 169 */ 433 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAA 170 */ 434 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAB 171 */ 435 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAC 172 */ 436 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAD 173 */ 437 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAE 174 */ 438 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xAF 175 */ 439 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB0 176 */ 440 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB1 177 */ 441 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB2 178 */ 442 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB3 179 */ 443 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB4 180 */ 444 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB5 181 */ 445 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB6 182 */ 446 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB7 183 */ 447 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB8 184 */ 448 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xB9 185 */ 449 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBA 186 */ 450 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBB 187 */ 451 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBC 188 */ 452 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBD 189 */ 453 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBE 190 */ 454 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xBF 191 */ 455 { SMB_SDT_OPS(open_print_file), /* 0xC0 192 */ 456 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 457 { "SmbOpenPrintFile", KSTAT_DATA_UINT64 } }, 458 { SMB_SDT_OPS(write_print_file), /* 0xC1 193 */ 459 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 460 { "SmbWritePrintFile", KSTAT_DATA_UINT64 } }, 461 { SMB_SDT_OPS(close_print_file), /* 0xC2 194 */ 462 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 463 { "SmbClosePrintFile", KSTAT_DATA_UINT64 } }, 464 { SMB_SDT_OPS(get_print_queue), /* 0xC3 195 */ 465 PC_NETWORK_PROGRAM_1_0, 0, RW_READER, 466 { "SmbGetPrintQueue", KSTAT_DATA_UINT64 } }, 467 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC4 196 */ 468 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC5 197 */ 469 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC6 198 */ 470 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC7 199 */ 471 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC8 200 */ 472 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xC9 201 */ 473 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCA 202 */ 474 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCB 203 */ 475 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCC 204 */ 476 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCD 205 */ 477 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCE 206 */ 478 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xCF 207 */ 479 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD0 208 */ 480 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD1 209 */ 481 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD2 210 */ 482 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD3 211 */ 483 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD4 212 */ 484 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD5 213 */ 485 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD6 214 */ 486 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD7 215 */ 487 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD8 216 */ 488 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xD9 217 */ 489 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDA 218 */ 490 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDB 219 */ 491 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDC 220 */ 492 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDD 221 */ 493 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDE 222 */ 494 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xDF 223 */ 495 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE0 224 */ 496 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE1 225 */ 497 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE2 226 */ 498 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE3 227 */ 499 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE4 228 */ 500 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE5 229 */ 501 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE6 230 */ 502 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE7 231 */ 503 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE8 232 */ 504 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xE9 233 */ 505 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xEA 234 */ 506 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xEB 235 */ 507 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xEC 236 */ 508 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xED 237 */ 509 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xEE 238 */ 510 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xEF 239 */ 511 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF0 240 */ 512 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF1 241 */ 513 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF2 242 */ 514 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF3 243 */ 515 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF4 244 */ 516 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF5 245 */ 517 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF6 246 */ 518 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF7 247 */ 519 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF8 248 */ 520 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xF9 249 */ 521 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xFA 250 */ 522 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xFB 251 */ 523 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xFC 252 */ 524 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 }, /* 0xFD 253 */ 525 { SMB_SDT_OPS(invalid), LANMAN1_0, 0, RW_READER, /* 0xFE 254 */ 526 { "SmbInvalidCommand", KSTAT_DATA_UINT64 } }, 527 { SMB_SDT_OPS(invalid), 0, 0, RW_READER, 0 } /* 0xFF 255 */ 528 }; 529 530 /* 531 * smbsr_cleanup 532 * 533 * If any user/tree/file is used by given request then 534 * the reference count for that resource has been incremented. 535 * This function decrements the reference count and close 536 * the resource if it's needed. 537 */ 538 539 void 540 smbsr_cleanup(smb_request_t *sr) 541 { 542 ASSERT((sr->sr_state != SMB_REQ_STATE_CLEANED_UP) && 543 (sr->sr_state != SMB_REQ_STATE_COMPLETED)); 544 545 if (sr->r_xa) { 546 if (sr->r_xa->xa_flags & SMB_XA_FLAG_COMPLETE) 547 smb_xa_close(sr->r_xa); 548 smb_xa_rele(sr->session, sr->r_xa); 549 sr->r_xa = NULL; 550 } 551 552 /* 553 * Mark this request so we know that we've already cleaned it up. 554 * A request should only get cleaned up once so multiple calls to 555 * smbsr_cleanup for the same request indicate a bug. 556 */ 557 mutex_enter(&sr->sr_mutex); 558 if (sr->sr_state != SMB_REQ_STATE_CANCELED) 559 sr->sr_state = SMB_REQ_STATE_CLEANED_UP; 560 mutex_exit(&sr->sr_mutex); 561 } 562 /* 563 * smb_dispatch_request 564 * 565 * Returns: 566 * 567 * B_TRUE The caller must free the smb request passed in. 568 * B_FALSE The caller must not access the smb request passed in. It has 569 * been kept in an internal queue and may have already been freed. 570 */ 571 boolean_t 572 smb_dispatch_request(struct smb_request *sr) 573 { 574 smb_sdrc_t sdrc; 575 smb_disp_entry_t *sdd; 576 boolean_t disconnect = B_FALSE; 577 smb_session_t *session; 578 uint32_t capabilities; 579 uint32_t byte_count; 580 581 session = sr->session; 582 capabilities = session->capabilities; 583 584 ASSERT(sr->tid_tree == 0); 585 ASSERT(sr->uid_user == 0); 586 ASSERT(sr->fid_ofile == 0); 587 sr->smb_fid = (uint16_t)-1; 588 589 /* temporary until we identify a user */ 590 sr->user_cr = kcred; 591 sr->orig_request_hdr = sr->command.chain_offset; 592 593 /* If this connection is shutting down just kill request */ 594 if (smb_mbc_decodef(&sr->command, SMB_HEADER_ED_FMT, 595 &sr->smb_com, 596 &sr->smb_rcls, 597 &sr->smb_reh, 598 &sr->smb_err, 599 &sr->smb_flg, 600 &sr->smb_flg2, 601 &sr->smb_pid_high, 602 sr->smb_sig, 603 &sr->smb_tid, 604 &sr->smb_pid, 605 &sr->smb_uid, 606 &sr->smb_mid) != 0) { 607 disconnect = B_TRUE; 608 goto drop_connection; 609 } 610 611 /* 612 * The reply "header" is filled in now even though it will, 613 * most likely, be rewritten under reply_ready below. We 614 * could reserve the space but this is convenient in case 615 * the dialect dispatcher has to send a special reply (like 616 * TRANSACT). 617 * 618 * Ensure that the 32-bit error code flag is turned off. 619 * Clients seem to set it in transact requests and they may 620 * get confused if we return success or a 16-bit SMB code. 621 */ 622 sr->smb_rcls = 0; 623 sr->smb_reh = 0; 624 sr->smb_err = 0; 625 sr->smb_flg2 &= ~SMB_FLAGS2_NT_STATUS; 626 627 (void) smb_mbc_encodef(&sr->reply, SMB_HEADER_ED_FMT, 628 sr->smb_com, 629 sr->smb_rcls, 630 sr->smb_reh, 631 sr->smb_err, 632 sr->smb_flg, 633 sr->smb_flg2, 634 sr->smb_pid_high, 635 sr->smb_sig, 636 sr->smb_tid, 637 sr->smb_pid, 638 sr->smb_uid, 639 sr->smb_mid); 640 sr->first_smb_com = sr->smb_com; 641 642 /* 643 * Verify SMB signature if signing is enabled, dialect is NT LM 0.12, 644 * signing was negotiated and authentication has occurred. 645 */ 646 if (session->signing.flags & SMB_SIGNING_ENABLED) { 647 if (smb_sign_check_request(sr) != 0) { 648 smbsr_error(sr, NT_STATUS_ACCESS_DENIED, 649 ERRDOS, ERROR_ACCESS_DENIED); 650 disconnect = B_TRUE; 651 smb_rwx_rwenter(&session->s_lock, RW_READER); 652 goto report_error; 653 } 654 } 655 656 andx_more: 657 sdd = &dispatch[sr->smb_com]; 658 ASSERT(sdd->sdt_function); 659 660 smb_rwx_rwenter(&session->s_lock, sdd->sdt_slock_mode); 661 662 if (smb_mbc_decodef(&sr->command, "b", &sr->smb_wct) != 0) { 663 disconnect = B_TRUE; 664 goto report_error; 665 } 666 667 (void) MBC_SHADOW_CHAIN(&sr->smb_vwv, &sr->command, 668 sr->command.chain_offset, sr->smb_wct * 2); 669 670 if (smb_mbc_decodef(&sr->command, "#.w", sr->smb_wct*2, &sr->smb_bcc)) { 671 disconnect = B_TRUE; 672 goto report_error; 673 } 674 675 /* 676 * Ignore smb_bcc if CAP_LARGE_READX/CAP_LARGE_WRITEX 677 * and this is SmbReadX/SmbWriteX since this enables 678 * large reads/write and bcc is only 16-bits. 679 */ 680 if (((sr->smb_com == SMB_COM_READ_ANDX) && 681 (capabilities & CAP_LARGE_READX)) || 682 ((sr->smb_com == SMB_COM_WRITE_ANDX) && 683 (capabilities & CAP_LARGE_WRITEX))) { 684 byte_count = sr->command.max_bytes - sr->command.chain_offset; 685 } else { 686 byte_count = (uint32_t)sr->smb_bcc; 687 } 688 689 (void) MBC_SHADOW_CHAIN(&sr->smb_data, &sr->command, 690 sr->command.chain_offset, byte_count); 691 692 sr->command.chain_offset += byte_count; 693 if (sr->command.chain_offset > sr->command.max_bytes) { 694 disconnect = B_TRUE; 695 goto report_error; 696 } 697 698 /* Store pointers for later */ 699 sr->cur_reply_offset = sr->reply.chain_offset; 700 701 if (is_andx_com(sr->smb_com)) { 702 /* Peek ahead and don't disturb vwv */ 703 if (smb_mbc_peek(&sr->smb_vwv, sr->smb_vwv.chain_offset, "b.w", 704 &sr->andx_com, &sr->andx_off) < 0) { 705 disconnect = B_TRUE; 706 goto report_error; 707 } 708 } else { 709 sr->andx_com = (unsigned char)-1; 710 } 711 712 mutex_enter(&sr->sr_mutex); 713 switch (sr->sr_state) { 714 case SMB_REQ_STATE_SUBMITTED: 715 case SMB_REQ_STATE_CLEANED_UP: 716 sr->sr_state = SMB_REQ_STATE_ACTIVE; 717 break; 718 case SMB_REQ_STATE_CANCELED: 719 break; 720 default: 721 ASSERT(0); 722 break; 723 } 724 mutex_exit(&sr->sr_mutex); 725 726 /* 727 * Setup UID and TID information (if required). Both functions 728 * will set the sr credentials. In domain mode, the user and 729 * tree credentials should be the same. In share mode, the 730 * tree credentials (defined in the share definition) should 731 * override the user credentials. 732 */ 733 if (!(sdd->sdt_flags & SDDF_SUPPRESS_UID) && (sr->uid_user == NULL)) { 734 sr->uid_user = smb_user_lookup_by_uid(session, sr->smb_uid); 735 if (sr->uid_user == NULL) { 736 smbsr_error(sr, 0, ERRSRV, ERRbaduid); 737 smbsr_cleanup(sr); 738 goto report_error; 739 } 740 741 sr->user_cr = smb_user_getcred(sr->uid_user); 742 743 if (!(sdd->sdt_flags & SDDF_SUPPRESS_TID) && 744 (sr->tid_tree == NULL)) { 745 sr->tid_tree = smb_user_lookup_tree( 746 sr->uid_user, sr->smb_tid); 747 if (sr->tid_tree == NULL) { 748 smbsr_error(sr, 0, ERRSRV, ERRinvnid); 749 smbsr_cleanup(sr); 750 goto report_error; 751 } 752 } 753 } 754 755 /* 756 * If the command is not a read raw request we can set the 757 * state of the session back to SMB_SESSION_STATE_NEGOTIATED 758 * (if the current state is SMB_SESSION_STATE_OPLOCK_BREAKING). 759 * Otherwise we let the read raw handler to deal with it. 760 */ 761 if ((session->s_state == SMB_SESSION_STATE_OPLOCK_BREAKING) && 762 (sr->smb_com != SMB_COM_READ_RAW)) { 763 krw_t mode; 764 /* 765 * The lock may have to be upgraded because, at this 766 * point, we don't know how it was entered. We just 767 * know that it has to be entered in writer mode here. 768 * Whatever mode was used to enter the lock, it will 769 * be restored. 770 */ 771 mode = smb_rwx_rwupgrade(&session->s_lock); 772 if (session->s_state == SMB_SESSION_STATE_OPLOCK_BREAKING) 773 session->s_state = SMB_SESSION_STATE_NEGOTIATED; 774 775 smb_rwx_rwdowngrade(&session->s_lock, mode); 776 } 777 778 /* 779 * Increment method invocation count. This value is exposed 780 * via kstats, and it represents a count of all the dispatched 781 * requests, including the ones that have a return value, other 782 * than SDRC_SUCCESS. 783 */ 784 SMB_ALL_DISPATCH_STAT_INCR(sdd->sdt_dispatch_stats.value.ui64); 785 786 if ((sdrc = (*sdd->sdt_pre_op)(sr)) == SDRC_SUCCESS) 787 sdrc = (*sdd->sdt_function)(sr); 788 789 if (sdrc != SDRC_SUCCESS) { 790 /* 791 * Handle errors from raw write. 792 */ 793 if (session->s_state == SMB_SESSION_STATE_WRITE_RAW_ACTIVE) { 794 /* 795 * Set state so that the netbios session 796 * daemon will start accepting data again. 797 */ 798 session->s_write_raw_status = 0; 799 session->s_state = SMB_SESSION_STATE_NEGOTIATED; 800 } 801 } 802 if (sdrc != SDRC_SR_KEPT) { 803 (*sdd->sdt_post_op)(sr); 804 smbsr_cleanup(sr); 805 } 806 807 switch (sdrc) { 808 case SDRC_SUCCESS: 809 break; 810 811 case SDRC_DROP_VC: 812 disconnect = B_TRUE; 813 goto drop_connection; 814 815 case SDRC_NO_REPLY: 816 smb_rwx_rwexit(&session->s_lock); 817 return (B_TRUE); 818 819 case SDRC_SR_KEPT: 820 smb_rwx_rwexit(&session->s_lock); 821 return (B_FALSE); 822 823 case SDRC_ERROR: 824 goto report_error; 825 826 case SDRC_NOT_IMPLEMENTED: 827 default: 828 smbsr_error(sr, 0, ERRDOS, ERRbadfunc); 829 goto report_error; 830 } 831 832 /* 833 * If there's no AndX command, we're done. 834 */ 835 if (sr->andx_com == 0xff) 836 goto reply_ready; 837 838 /* 839 * Otherwise, we have to back-patch the AndXCommand and AndXOffset 840 * and continue processing. 841 */ 842 sr->andx_prev_wct = sr->cur_reply_offset; 843 (void) smb_mbc_poke(&sr->reply, sr->andx_prev_wct + 1, "b.w", 844 sr->andx_com, MBC_LENGTH(&sr->reply)); 845 846 smb_rwx_rwexit(&session->s_lock); 847 848 sr->command.chain_offset = sr->orig_request_hdr + sr->andx_off; 849 sr->smb_com = sr->andx_com; 850 goto andx_more; 851 852 report_error: 853 sr->reply.chain_offset = sr->cur_reply_offset; 854 (void) smb_mbc_encodef(&sr->reply, "bw", 0, 0); 855 856 sr->smb_wct = 0; 857 sr->smb_bcc = 0; 858 859 if (sr->smb_rcls == 0 && sr->smb_reh == 0 && sr->smb_err == 0) 860 smbsr_error(sr, 0, ERRSRV, ERRerror); 861 862 reply_ready: 863 smbsr_send_reply(sr); 864 865 drop_connection: 866 if (disconnect) { 867 switch (session->s_state) { 868 case SMB_SESSION_STATE_DISCONNECTED: 869 case SMB_SESSION_STATE_TERMINATED: 870 break; 871 default: 872 smb_soshutdown(session->sock); 873 session->s_state = SMB_SESSION_STATE_DISCONNECTED; 874 break; 875 } 876 } 877 878 smb_rwx_rwexit(&session->s_lock); 879 880 return (B_TRUE); 881 } 882 883 int 884 smbsr_encode_empty_result(struct smb_request *sr) 885 { 886 return (smbsr_encode_result(sr, 0, 0, "bw", 0, 0)); 887 } 888 889 int 890 smbsr_encode_result(struct smb_request *sr, int wct, int bcc, char *fmt, ...) 891 { 892 va_list ap; 893 894 if (MBC_LENGTH(&sr->reply) != sr->cur_reply_offset) 895 return (-1); 896 897 va_start(ap, fmt); 898 (void) smb_mbc_vencodef(&sr->reply, fmt, ap); 899 va_end(ap); 900 901 sr->smb_wct = (unsigned char)wct; 902 sr->smb_bcc = (uint16_t)bcc; 903 904 if (smbsr_check_result(sr, wct, bcc) != 0) 905 return (-1); 906 907 return (0); 908 } 909 910 static int 911 smbsr_check_result(struct smb_request *sr, int wct, int bcc) 912 { 913 int offset = sr->cur_reply_offset; 914 int total_bytes; 915 unsigned char temp, temp1; 916 struct mbuf *m; 917 918 total_bytes = 0; 919 m = sr->reply.chain; 920 while (m != 0) { 921 total_bytes += m->m_len; 922 m = m->m_next; 923 } 924 925 if ((offset + 3) > total_bytes) 926 return (-1); 927 928 (void) smb_mbc_peek(&sr->reply, offset, "b", &temp); 929 if (temp != wct) 930 return (-1); 931 932 if ((offset + (wct * 2 + 1)) > total_bytes) 933 return (-1); 934 935 /* reply wct & vwv seem ok, consider data now */ 936 offset += wct * 2 + 1; 937 938 if ((offset + 2) > total_bytes) 939 return (-1); 940 941 (void) smb_mbc_peek(&sr->reply, offset, "bb", &temp, &temp1); 942 if (bcc == VAR_BCC) { 943 if ((temp != 0xFF) || (temp1 != 0xFF)) { 944 return (-1); 945 } else { 946 bcc = (total_bytes - offset) - 2; 947 (void) smb_mbc_poke(&sr->reply, offset, "bb", 948 bcc, bcc >> 8); 949 } 950 } else { 951 if ((temp != (bcc&0xFF)) || (temp1 != ((bcc>>8)&0xFF))) 952 return (-1); 953 } 954 955 offset += bcc + 2; 956 957 if (offset != total_bytes) 958 return (-1); 959 960 sr->smb_wct = (unsigned char)wct; 961 sr->smb_bcc = (uint16_t)bcc; 962 return (0); 963 } 964 965 int 966 smbsr_decode_vwv(struct smb_request *sr, char *fmt, ...) 967 { 968 int rc; 969 va_list ap; 970 971 va_start(ap, fmt); 972 rc = smb_mbc_vdecodef(&sr->smb_vwv, fmt, ap); 973 va_end(ap); 974 975 if (rc) 976 smbsr_error(sr, 0, ERRSRV, ERRerror); 977 return (rc); 978 } 979 980 int 981 smbsr_decode_data(struct smb_request *sr, char *fmt, ...) 982 { 983 int rc; 984 va_list ap; 985 986 va_start(ap, fmt); 987 rc = smb_mbc_vdecodef(&sr->smb_data, fmt, ap); 988 va_end(ap); 989 990 if (rc) 991 smbsr_error(sr, 0, ERRSRV, ERRerror); 992 return (rc); 993 } 994 995 void 996 smbsr_send_reply(struct smb_request *sr) 997 { 998 if (SMB_TREE_IS_CASEINSENSITIVE(sr)) 999 sr->smb_flg |= SMB_FLAGS_CASE_INSENSITIVE; 1000 else 1001 sr->smb_flg &= ~SMB_FLAGS_CASE_INSENSITIVE; 1002 1003 (void) smb_mbc_poke(&sr->reply, 0, SMB_HEADER_ED_FMT, 1004 sr->first_smb_com, 1005 sr->smb_rcls, 1006 sr->smb_reh, 1007 sr->smb_err, 1008 sr->smb_flg | SMB_FLAGS_REPLY, 1009 sr->smb_flg2, 1010 sr->smb_pid_high, 1011 sr->smb_sig, 1012 sr->smb_tid, 1013 sr->smb_pid, 1014 sr->smb_uid, 1015 sr->smb_mid); 1016 1017 if (sr->session->signing.flags & SMB_SIGNING_ENABLED) 1018 smb_sign_reply(sr, NULL); 1019 1020 if (smb_session_send(sr->session, 0, &sr->reply) == 0) 1021 sr->reply.chain = 0; 1022 } 1023 1024 /* 1025 * Map errno values to SMB and NT status values. 1026 * Note: ESRCH is a special case to handle a streams lookup failure. 1027 */ 1028 static struct { 1029 int errnum; 1030 int errcls; 1031 int errcode; 1032 DWORD status32; 1033 } smb_errno_map[] = { 1034 { ENOSPC, ERRDOS, ERROR_DISK_FULL, NT_STATUS_DISK_FULL }, 1035 { EDQUOT, ERRDOS, ERROR_DISK_FULL, NT_STATUS_DISK_FULL }, 1036 { EPERM, ERRSRV, ERRaccess, NT_STATUS_ACCESS_DENIED }, 1037 { ENOTDIR, ERRDOS, ERRbadpath, NT_STATUS_OBJECT_PATH_NOT_FOUND }, 1038 { EISDIR, ERRDOS, ERRbadpath, NT_STATUS_FILE_IS_A_DIRECTORY }, 1039 { ENOENT, ERRDOS, ERRbadfile, NT_STATUS_NO_SUCH_FILE }, 1040 { ENOTEMPTY, ERRDOS, ERROR_DIR_NOT_EMPTY, 1041 NT_STATUS_DIRECTORY_NOT_EMPTY }, 1042 { EILSEQ, ERRDOS, ERROR_INVALID_NAME, 1043 NT_STATUS_OBJECT_NAME_INVALID }, 1044 { EACCES, ERRDOS, ERRnoaccess, NT_STATUS_ACCESS_DENIED }, 1045 { ENOMEM, ERRDOS, ERRnomem, NT_STATUS_NO_MEMORY }, 1046 { EIO, ERRHRD, ERRgeneral, NT_STATUS_IO_DEVICE_ERROR }, 1047 { EXDEV, ERRSRV, ERRdiffdevice, NT_STATUS_NOT_SAME_DEVICE }, 1048 { EROFS, ERRHRD, ERRnowrite, NT_STATUS_ACCESS_DENIED }, 1049 { ESTALE, ERRDOS, ERRbadfid, NT_STATUS_INVALID_HANDLE }, 1050 { EBADF, ERRDOS, ERRbadfid, NT_STATUS_INVALID_HANDLE }, 1051 { EEXIST, ERRDOS, ERRfilexists, NT_STATUS_OBJECT_NAME_COLLISION }, 1052 { ENXIO, ERRSRV, ERRinvdevice, NT_STATUS_BAD_DEVICE_TYPE }, 1053 { ESRCH, ERRDOS, ERROR_FILE_NOT_FOUND, 1054 NT_STATUS_OBJECT_NAME_NOT_FOUND }, 1055 /* 1056 * It's not clear why smb_read_common effectively returns 1057 * ERRnoaccess if a range lock prevents access and smb_write_common 1058 * effectively returns ERRaccess. This table entry is used by 1059 * smb_read_common and preserves the behavior that was there before. 1060 */ 1061 { ERANGE, ERRDOS, ERRnoaccess, NT_STATUS_FILE_LOCK_CONFLICT } 1062 }; 1063 1064 void 1065 smbsr_map_errno(int errnum, smb_error_t *err) 1066 { 1067 int i; 1068 1069 for (i = 0; i < sizeof (smb_errno_map)/sizeof (smb_errno_map[0]); ++i) { 1070 if (smb_errno_map[i].errnum == errnum) { 1071 err->severity = ERROR_SEVERITY_ERROR; 1072 err->status = smb_errno_map[i].status32; 1073 err->errcls = smb_errno_map[i].errcls; 1074 err->errcode = smb_errno_map[i].errcode; 1075 return; 1076 } 1077 } 1078 1079 err->severity = ERROR_SEVERITY_ERROR; 1080 err->status = NT_STATUS_INTERNAL_ERROR; 1081 err->errcls = ERRDOS; 1082 err->errcode = ERROR_INTERNAL_ERROR; 1083 } 1084 1085 void 1086 smbsr_errno(struct smb_request *sr, int errnum) 1087 { 1088 smbsr_map_errno(errnum, &sr->smb_error); 1089 smbsr_set_error(sr, &sr->smb_error); 1090 } 1091 1092 /* 1093 * Report a request processing warning. 1094 */ 1095 void 1096 smbsr_warn(smb_request_t *sr, DWORD status, uint16_t errcls, uint16_t errcode) 1097 { 1098 sr->smb_error.severity = ERROR_SEVERITY_WARNING; 1099 sr->smb_error.status = status; 1100 sr->smb_error.errcls = errcls; 1101 sr->smb_error.errcode = errcode; 1102 1103 smbsr_set_error(sr, &sr->smb_error); 1104 } 1105 1106 /* 1107 * Report a request processing error. This function will not return. 1108 */ 1109 void 1110 smbsr_error(smb_request_t *sr, DWORD status, uint16_t errcls, uint16_t errcode) 1111 { 1112 sr->smb_error.severity = ERROR_SEVERITY_ERROR; 1113 sr->smb_error.status = status; 1114 sr->smb_error.errcls = errcls; 1115 sr->smb_error.errcode = errcode; 1116 1117 smbsr_set_error(sr, &sr->smb_error); 1118 } 1119 1120 /* 1121 * Setup a request processing error. This function can be used to 1122 * report 32-bit status codes or DOS errors. Set the status code 1123 * to 0 (NT_STATUS_SUCCESS) to explicitly report a DOS error, 1124 * regardless of the client capabilities. 1125 * 1126 * If status is non-zero and the client supports 32-bit status 1127 * codes, report the status. Otherwise, report the DOS error. 1128 */ 1129 void 1130 smbsr_set_error(smb_request_t *sr, smb_error_t *err) 1131 { 1132 uint32_t status; 1133 uint32_t severity; 1134 uint32_t capabilities; 1135 1136 ASSERT(sr); 1137 ASSERT(err); 1138 1139 status = err->status; 1140 severity = (err->severity == 0) ? ERROR_SEVERITY_ERROR : err->severity; 1141 capabilities = sr->session->capabilities; 1142 1143 if ((err->errcls == 0) && (err->errcode == 0)) { 1144 capabilities |= CAP_STATUS32; 1145 if (status == 0) 1146 status = NT_STATUS_INTERNAL_ERROR; 1147 } 1148 1149 if ((capabilities & CAP_STATUS32) && (status != 0)) { 1150 status |= severity; 1151 sr->smb_rcls = status & 0xff; 1152 sr->smb_reh = (status >> 8) & 0xff; 1153 sr->smb_err = status >> 16; 1154 sr->smb_flg2 |= SMB_FLAGS2_NT_STATUS; 1155 } else { 1156 if ((err->errcls == 0) || (err->errcode == 0)) { 1157 sr->smb_rcls = ERRSRV; 1158 sr->smb_err = ERRerror; 1159 } else { 1160 sr->smb_rcls = (uint8_t)err->errcls; 1161 sr->smb_err = (uint16_t)err->errcode; 1162 } 1163 } 1164 } 1165 1166 smb_xa_t * 1167 smbsr_lookup_xa(smb_request_t *sr) 1168 { 1169 ASSERT(sr->r_xa == 0); 1170 1171 sr->r_xa = smb_xa_find(sr->session, sr->smb_pid, sr->smb_mid); 1172 return (sr->r_xa); 1173 } 1174 1175 void 1176 smbsr_disconnect_file(smb_request_t *sr) 1177 { 1178 smb_ofile_t *of = sr->fid_ofile; 1179 1180 sr->fid_ofile = NULL; 1181 (void) smb_ofile_release(of); 1182 } 1183 1184 void 1185 smbsr_lookup_file(smb_request_t *sr) 1186 { 1187 if (sr->fid_ofile == NULL) 1188 sr->fid_ofile = smb_ofile_lookup_by_fid(sr->tid_tree, 1189 sr->smb_fid); 1190 } 1191 1192 static int 1193 is_andx_com(unsigned char com) 1194 { 1195 switch (com) { 1196 case SMB_COM_LOCKING_ANDX: 1197 case SMB_COM_OPEN_ANDX: 1198 case SMB_COM_READ_ANDX: 1199 case SMB_COM_WRITE_ANDX: 1200 case SMB_COM_SESSION_SETUP_ANDX: 1201 case SMB_COM_LOGOFF_ANDX: 1202 case SMB_COM_TREE_CONNECT_ANDX: 1203 case SMB_COM_NT_CREATE_ANDX: 1204 return (1); 1205 } 1206 return (0); 1207 } 1208 1209 /* 1210 * Invalid command stubs. 1211 * 1212 * SmbWriteComplete is sent to acknowledge completion of raw write requests. 1213 * We never send raw write commands to other servers so, if we receive 1214 * SmbWriteComplete, we treat it as an error. 1215 * 1216 * The Read/Write Block Multiplexed (mpx) protocol is used to maximize 1217 * performance when reading/writing a large block of data: it can be 1218 * used in parallel with other client/server operations. The mpx sub- 1219 * protocol is not supported because we support only connection oriented 1220 * transports and NT supports mpx only over connectionless transports. 1221 */ 1222 smb_sdrc_t 1223 smb_pre_invalid(smb_request_t *sr) 1224 { 1225 DTRACE_SMB_1(op__Invalid__start, smb_request_t *, sr); 1226 return (SDRC_SUCCESS); 1227 } 1228 1229 void 1230 smb_post_invalid(smb_request_t *sr) 1231 { 1232 DTRACE_SMB_1(op__Invalid__done, smb_request_t *, sr); 1233 } 1234 1235 smb_sdrc_t 1236 smb_com_invalid(smb_request_t *sr) 1237 { 1238 smb_sdrc_t sdrc; 1239 1240 switch (sr->smb_com) { 1241 case SMB_COM_WRITE_COMPLETE: 1242 smbsr_error(sr, 0, ERRSRV, ERRerror); 1243 sdrc = SDRC_ERROR; 1244 break; 1245 1246 default: 1247 smbsr_error(sr, NT_STATUS_NOT_IMPLEMENTED, 1248 ERRDOS, ERROR_INVALID_FUNCTION); 1249 sdrc = SDRC_NOT_IMPLEMENTED; 1250 break; 1251 } 1252 1253 return (sdrc); 1254 } 1255 1256 /* 1257 * smb_dispatch_kstat_update 1258 * 1259 * This callback function updates the smb_dispatch_kstat_data when kstat 1260 * command is invoked. 1261 */ 1262 static int 1263 smb_dispatch_kstat_update(kstat_t *ksp, int rw) 1264 { 1265 smb_disp_entry_t *sdd; 1266 kstat_named_t *ks_named; 1267 int i; 1268 1269 if (rw == KSTAT_WRITE) 1270 return (EACCES); 1271 1272 ASSERT(MUTEX_HELD(ksp->ks_lock)); 1273 1274 ks_named = ksp->ks_data; 1275 for (i = 0; i < SMB_COM_NUM; i++) { 1276 sdd = &dispatch[i]; 1277 1278 if (sdd->sdt_function != smb_com_invalid) { 1279 bcopy(&sdd->sdt_dispatch_stats, ks_named, 1280 sizeof (kstat_named_t)); 1281 ++ks_named; 1282 } 1283 } 1284 1285 return (0); 1286 } 1287 1288 /* 1289 * smb_dispatch_kstat_init 1290 * 1291 * Initialize dispatch kstats. 1292 */ 1293 void 1294 smb_dispatch_kstat_init(void) 1295 { 1296 int ks_ndata; 1297 int i; 1298 1299 for (i = 0, ks_ndata = 0; i < SMB_COM_NUM; i++) { 1300 if (dispatch[i].sdt_function != smb_com_invalid) 1301 ks_ndata++; 1302 } 1303 1304 smb_dispatch_ksp = kstat_create(SMBSRV_KSTAT_MODULE, 0, 1305 SMBSRV_KSTAT_NAME_CMDS, SMBSRV_KSTAT_CLASS, 1306 KSTAT_TYPE_NAMED, ks_ndata, 0); 1307 1308 if (smb_dispatch_ksp) { 1309 mutex_init(&smb_dispatch_ksmtx, NULL, MUTEX_DEFAULT, NULL); 1310 smb_dispatch_ksp->ks_update = smb_dispatch_kstat_update; 1311 smb_dispatch_ksp->ks_lock = &smb_dispatch_ksmtx; 1312 kstat_install(smb_dispatch_ksp); 1313 } 1314 } 1315 1316 /* 1317 * smb_dispatch_kstat_fini 1318 * 1319 * Remove dispatch kstats. 1320 */ 1321 void 1322 smb_dispatch_kstat_fini(void) 1323 { 1324 if (smb_dispatch_ksp != NULL) { 1325 kstat_delete(smb_dispatch_ksp); 1326 mutex_destroy(&smb_dispatch_ksmtx); 1327 smb_dispatch_ksp = NULL; 1328 } 1329 } 1330