1/* 2 * fs/cifs/cifsglob.h 3 * 4 * Copyright (C) International Business Machines Corp., 2002,2006 5 * Author(s): Steve French (sfrench@us.ibm.com) 6 * Jeremy Allison (jra@samba.org) 7 * 8 * This library is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU Lesser General Public License as published 10 * by the Free Software Foundation; either version 2.1 of the License, or 11 * (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 16 * the GNU Lesser General Public License for more details. 17 * 18 */ 19#include <linux/in.h> 20#include <linux/in6.h> 21#include "cifs_fs_sb.h" 22/* 23 * The sizes of various internal tables and strings 24 */ 25#define MAX_UID_INFO 16 26#define MAX_SES_INFO 2 27#define MAX_TCON_INFO 4 28 29#define MAX_TREE_SIZE 2 + MAX_SERVER_SIZE + 1 + MAX_SHARE_SIZE + 1 30#define MAX_SERVER_SIZE 15 31#define MAX_SHARE_SIZE 64 /* used to be 20 - this should still be enough */ 32#define MAX_USERNAME_SIZE 32 /* 32 is to allow for 15 char names + null 33 termination then *2 for unicode versions */ 34#define MAX_PASSWORD_SIZE 16 35 36#define CIFS_MIN_RCV_POOL 4 37 38/* 39 * MAX_REQ is the maximum number of requests that WE will send 40 * on one socket concurently. It also matches the most common 41 * value of max multiplex returned by servers. We may 42 * eventually want to use the negotiated value (in case 43 * future servers can handle more) when we are more confident that 44 * we will not have problems oveloading the socket with pending 45 * write data. 46 */ 47#define CIFS_MAX_REQ 50 48 49#define SERVER_NAME_LENGTH 15 50#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1) 51 52/* used to define string lengths for reversing unicode strings */ 53/* (256+1)*2 = 514 */ 54/* (max path length + 1 for null) * 2 for unicode */ 55#define MAX_NAME 514 56 57#include "cifspdu.h" 58 59#ifndef FALSE 60#define FALSE 0 61#endif 62 63#ifndef TRUE 64#define TRUE 1 65#endif 66 67#ifndef XATTR_DOS_ATTRIB 68#define XATTR_DOS_ATTRIB "user.DOSATTRIB" 69#endif 70 71/* 72 * This information is kept on every Server we know about. 73 * 74 * Some things to note: 75 * 76 */ 77#define SERVER_NAME_LEN_WITH_NULL (SERVER_NAME_LENGTH + 1) 78 79/* 80 * CIFS vfs client Status information (based on what we know.) 81 */ 82 83 /* associated with each tcp and smb session */ 84enum statusEnum { 85 CifsNew = 0, 86 CifsGood, 87 CifsExiting, 88 CifsNeedReconnect 89}; 90 91enum securityEnum { 92 LANMAN = 0, /* Legacy LANMAN auth */ 93 NTLM, /* Legacy NTLM012 auth with NTLM hash */ 94 NTLMv2, /* Legacy NTLM auth with NTLMv2 hash */ 95 RawNTLMSSP, /* NTLMSSP without SPNEGO */ 96 NTLMSSP, /* NTLMSSP via SPNEGO */ 97 Kerberos /* Kerberos via SPNEGO */ 98}; 99 100enum protocolEnum { 101 IPV4 = 0, 102 IPV6, 103 SCTP 104 /* Netbios frames protocol not supported at this time */ 105}; 106 107/* 108 ***************************************************************** 109 * Except the CIFS PDUs themselves all the 110 * globally interesting structs should go here 111 ***************************************************************** 112 */ 113 114struct TCP_Server_Info { 115 /* 15 character server name + 0x20 16th byte indicating type = srv */ 116 char server_RFC1001_name[SERVER_NAME_LEN_WITH_NULL]; 117 char unicode_server_Name[SERVER_NAME_LEN_WITH_NULL * 2]; 118 struct socket *ssocket; 119 union { 120 struct sockaddr_in sockAddr; 121 struct sockaddr_in6 sockAddr6; 122 } addr; 123 wait_queue_head_t response_q; 124 wait_queue_head_t request_q; /* if more than maxmpx to srvr must block*/ 125 struct list_head pending_mid_q; 126 void *Server_NlsInfo; /* BB - placeholder for future NLS info */ 127 unsigned short server_codepage; /* codepage for the server */ 128 unsigned long ip_address; /* IP addr for the server if known */ 129 enum protocolEnum protocolType; 130 char versionMajor; 131 char versionMinor; 132 unsigned svlocal:1; /* local server or remote */ 133 atomic_t socketUseCount; /* number of open cifs sessions on socket */ 134 atomic_t inFlight; /* number of requests on the wire to server */ 135#ifdef CONFIG_CIFS_STATS2 136 atomic_t inSend; /* requests trying to send */ 137 atomic_t num_waiters; /* blocked waiting to get in sendrecv */ 138#endif 139 enum statusEnum tcpStatus; /* what we think the status is */ 140 struct semaphore tcpSem; 141 struct task_struct *tsk; 142 char server_GUID[16]; 143 char secMode; 144 enum securityEnum secType; 145 unsigned int maxReq; /* Clients should submit no more */ 146 /* than maxReq distinct unanswered SMBs to the server when using */ 147 /* multiplexed reads or writes */ 148 unsigned int maxBuf; /* maxBuf specifies the maximum */ 149 /* message size the server can send or receive for non-raw SMBs */ 150 unsigned int maxRw; /* maxRw specifies the maximum */ 151 /* message size the server can send or receive for */ 152 /* SMB_COM_WRITE_RAW or SMB_COM_READ_RAW. */ 153 char sessid[4]; /* unique token id for this session */ 154 /* (returned on Negotiate */ 155 int capabilities; /* allow selective disabling of caps by smb sess */ 156 int timeAdj; /* Adjust for difference in server time zone in sec */ 157 __u16 CurrentMid; /* multiplex id - rotating counter */ 158 char cryptKey[CIFS_CRYPTO_KEY_SIZE]; 159 /* 16th byte of RFC1001 workstation name is always null */ 160 char workstation_RFC1001_name[SERVER_NAME_LEN_WITH_NULL]; 161 __u32 sequence_number; /* needed for CIFS PDU signature */ 162 char mac_signing_key[CIFS_SESS_KEY_SIZE + 16]; 163 unsigned long lstrp; /* when we got last response from this server */ 164}; 165 166/* 167 * The following is our shortcut to user information. We surface the uid, 168 * and name. We always get the password on the fly in case it 169 * has changed. We also hang a list of sessions owned by this user off here. 170 */ 171struct cifsUidInfo { 172 struct list_head userList; 173 struct list_head sessionList; /* SMB sessions for this user */ 174 uid_t linux_uid; 175 char user[MAX_USERNAME_SIZE + 1]; /* ascii name of user */ 176 /* BB may need ptr or callback for PAM or WinBind info */ 177}; 178 179/* 180 * Session structure. One of these for each uid session with a particular host 181 */ 182struct cifsSesInfo { 183 struct list_head cifsSessionList; 184 struct semaphore sesSem; 185 struct TCP_Server_Info *server; /* pointer to server info */ 186 atomic_t inUse; /* # of mounts (tree connections) on this ses */ 187 enum statusEnum status; 188 unsigned overrideSecFlg; /* if non-zero override global sec flags */ 189 __u16 ipc_tid; /* special tid for connection to IPC share */ 190 __u16 flags; 191 char *serverOS; /* name of operating system underlying server */ 192 char *serverNOS; /* name of network operating system of server */ 193 char *serverDomain; /* security realm of server */ 194 int Suid; /* remote smb uid */ 195 uid_t linux_uid; /* local Linux uid */ 196 int capabilities; 197 char serverName[SERVER_NAME_LEN_WITH_NULL * 2]; /* BB make bigger for 198 TCP names - will ipv6 and sctp addresses fit? */ 199 char userName[MAX_USERNAME_SIZE + 1]; 200 char * domainName; 201 char * password; 202}; 203/* no more than one of the following three session flags may be set */ 204#define CIFS_SES_NT4 1 205#define CIFS_SES_OS2 2 206#define CIFS_SES_W9X 4 207/* following flag is set for old servers such as OS2 (and Win95?) 208 which do not negotiate NTLM or POSIX dialects, but instead 209 negotiate one of the older LANMAN dialects */ 210#define CIFS_SES_LANMAN 8 211/* 212 * there is one of these for each connection to a resource on a particular 213 * session 214 */ 215struct cifsTconInfo { 216 struct list_head cifsConnectionList; 217 struct list_head openFileList; 218 struct semaphore tconSem; 219 struct cifsSesInfo *ses; /* pointer to session associated with */ 220 char treeName[MAX_TREE_SIZE + 1]; /* UNC name of resource in ASCII */ 221 char *nativeFileSystem; 222 __u16 tid; /* The 2 byte tree id */ 223 __u16 Flags; /* optional support bits */ 224 enum statusEnum tidStatus; 225 atomic_t useCount; /* how many explicit/implicit mounts to share */ 226#ifdef CONFIG_CIFS_STATS 227 atomic_t num_smbs_sent; 228 atomic_t num_writes; 229 atomic_t num_reads; 230 atomic_t num_oplock_brks; 231 atomic_t num_opens; 232 atomic_t num_closes; 233 atomic_t num_deletes; 234 atomic_t num_mkdirs; 235 atomic_t num_rmdirs; 236 atomic_t num_renames; 237 atomic_t num_t2renames; 238 atomic_t num_ffirst; 239 atomic_t num_fnext; 240 atomic_t num_fclose; 241 atomic_t num_hardlinks; 242 atomic_t num_symlinks; 243 atomic_t num_locks; 244 atomic_t num_acl_get; 245 atomic_t num_acl_set; 246#ifdef CONFIG_CIFS_STATS2 247 unsigned long long time_writes; 248 unsigned long long time_reads; 249 unsigned long long time_opens; 250 unsigned long long time_deletes; 251 unsigned long long time_closes; 252 unsigned long long time_mkdirs; 253 unsigned long long time_rmdirs; 254 unsigned long long time_renames; 255 unsigned long long time_t2renames; 256 unsigned long long time_ffirst; 257 unsigned long long time_fnext; 258 unsigned long long time_fclose; 259#endif /* CONFIG_CIFS_STATS2 */ 260 __u64 bytes_read; 261 __u64 bytes_written; 262 spinlock_t stat_lock; 263#endif /* CONFIG_CIFS_STATS */ 264 FILE_SYSTEM_DEVICE_INFO fsDevInfo; 265 FILE_SYSTEM_ATTRIBUTE_INFO fsAttrInfo; /* ok if fs name truncated */ 266 FILE_SYSTEM_UNIX_INFO fsUnixInfo; 267 unsigned retry:1; 268 unsigned nocase:1; 269 /* BB add field for back pointer to sb struct? */ 270}; 271 272/* 273 * This info hangs off the cifsFileInfo structure, pointed to by llist. 274 * This is used to track byte stream locks on the file 275 */ 276struct cifsLockInfo { 277 struct list_head llist; /* pointer to next cifsLockInfo */ 278 __u64 offset; 279 __u64 length; 280 __u8 type; 281}; 282 283/* 284 * One of these for each open instance of a file 285 */ 286struct cifs_search_info { 287 loff_t index_of_last_entry; 288 __u16 entries_in_buffer; 289 __u16 info_level; 290 __u32 resume_key; 291 char * ntwrk_buf_start; 292 char * srch_entries_start; 293 char * presume_name; 294 unsigned int resume_name_len; 295 unsigned endOfSearch:1; 296 unsigned emptyDir:1; 297 unsigned unicode:1; 298 unsigned smallBuf:1; /* so we know which buf_release function to call */ 299}; 300 301struct cifsFileInfo { 302 struct list_head tlist; /* pointer to next fid owned by tcon */ 303 struct list_head flist; /* next fid (file instance) for this inode */ 304 unsigned int uid; /* allows finding which FileInfo structure */ 305 __u32 pid; /* process id who opened file */ 306 __u16 netfid; /* file id from remote */ 307 /* BB add lock scope info here if needed */ ; 308 /* lock scope id (0 if none) */ 309 struct file * pfile; /* needed for writepage */ 310 struct inode * pInode; /* needed for oplock break */ 311 struct mutex lock_mutex; 312 struct list_head llist; /* list of byte range locks we have. */ 313 unsigned closePend:1; /* file is marked to close */ 314 unsigned invalidHandle:1; /* file closed via session abend */ 315 atomic_t wrtPending; /* handle in use - defer close */ 316 struct semaphore fh_sem; /* prevents reopen race after dead ses*/ 317 char * search_resume_name; /* BB removeme BB */ 318 struct cifs_search_info srch_inf; 319}; 320 321/* 322 * One of these for each file inode 323 */ 324 325struct cifsInodeInfo { 326 struct list_head lockList; 327 /* BB add in lists for dirty pages - i.e. write caching info for oplock */ 328 struct list_head openFileList; 329 int write_behind_rc; 330 __u32 cifsAttrs; /* e.g. DOS archive bit, sparse, compressed, system */ 331 atomic_t inUse; /* num concurrent users (local openers cifs) of file*/ 332 unsigned long time; /* jiffies of last update/check of inode */ 333 unsigned clientCanCacheRead:1; /* read oplock */ 334 unsigned clientCanCacheAll:1; /* read and writebehind oplock */ 335 unsigned oplockPending:1; 336 struct inode vfs_inode; 337}; 338 339static inline struct cifsInodeInfo * 340CIFS_I(struct inode *inode) 341{ 342 return container_of(inode, struct cifsInodeInfo, vfs_inode); 343} 344 345static inline struct cifs_sb_info * 346CIFS_SB(struct super_block *sb) 347{ 348 return sb->s_fs_info; 349} 350 351static inline char CIFS_DIR_SEP(const struct cifs_sb_info *cifs_sb) 352{ 353 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) 354 return '/'; 355 else 356 return '\\'; 357} 358 359#ifdef CONFIG_CIFS_STATS 360#define cifs_stats_inc atomic_inc 361 362static inline void cifs_stats_bytes_written(struct cifsTconInfo *tcon, 363 unsigned int bytes) 364{ 365 if (bytes) { 366 spin_lock(&tcon->stat_lock); 367 tcon->bytes_written += bytes; 368 spin_unlock(&tcon->stat_lock); 369 } 370} 371 372static inline void cifs_stats_bytes_read(struct cifsTconInfo *tcon, 373 unsigned int bytes) 374{ 375 spin_lock(&tcon->stat_lock); 376 tcon->bytes_read += bytes; 377 spin_unlock(&tcon->stat_lock); 378} 379#else 380 381#define cifs_stats_inc(field) do {} while(0) 382#define cifs_stats_bytes_written(tcon, bytes) do {} while(0) 383#define cifs_stats_bytes_read(tcon, bytes) do {} while(0) 384 385#endif 386 387/* one of these for every pending CIFS request to the server */ 388struct mid_q_entry { 389 struct list_head qhead; /* mids waiting on reply from this server */ 390 __u16 mid; /* multiplex id */ 391 __u16 pid; /* process id */ 392 __u32 sequence_number; /* for CIFS signing */ 393 unsigned long when_alloc; /* when mid was created */ 394#ifdef CONFIG_CIFS_STATS2 395 unsigned long when_sent; /* time when smb send finished */ 396 unsigned long when_received; /* when demux complete (taken off wire) */ 397#endif 398 struct cifsSesInfo *ses; /* smb was sent to this server */ 399 struct task_struct *tsk; /* task waiting for response */ 400 struct smb_hdr *resp_buf; /* response buffer */ 401 int midState; /* wish this were enum but can not pass to wait_event */ 402 __u8 command; /* smb command code */ 403 unsigned largeBuf:1; /* if valid response, is pointer to large buf */ 404 unsigned multiRsp:1; /* multiple trans2 responses for one request */ 405 unsigned multiEnd:1; /* both received */ 406}; 407 408struct oplock_q_entry { 409 struct list_head qhead; 410 struct inode * pinode; 411 struct cifsTconInfo * tcon; 412 __u16 netfid; 413}; 414 415/* for pending dnotify requests */ 416struct dir_notify_req { 417 struct list_head lhead; 418 __le16 Pid; 419 __le16 PidHigh; 420 __u16 Mid; 421 __u16 Tid; 422 __u16 Uid; 423 __u16 netfid; 424 __u32 filter; /* CompletionFilter (for multishot) */ 425 int multishot; 426 struct file * pfile; 427}; 428 429#define MID_FREE 0 430#define MID_REQUEST_ALLOCATED 1 431#define MID_REQUEST_SUBMITTED 2 432#define MID_RESPONSE_RECEIVED 4 433#define MID_RETRY_NEEDED 8 /* session closed while this request out */ 434#define MID_NO_RESP_NEEDED 0x10 435 436/* Types of response buffer returned from SendReceive2 */ 437#define CIFS_NO_BUFFER 0 /* Response buffer not returned */ 438#define CIFS_SMALL_BUFFER 1 439#define CIFS_LARGE_BUFFER 2 440#define CIFS_IOVEC 4 /* array of response buffers */ 441 442/* Security Flags: indicate type of session setup needed */ 443#define CIFSSEC_MAY_SIGN 0x00001 444#define CIFSSEC_MAY_NTLM 0x00002 445#define CIFSSEC_MAY_NTLMV2 0x00004 446#define CIFSSEC_MAY_KRB5 0x00008 447#ifdef CONFIG_CIFS_WEAK_PW_HASH 448#define CIFSSEC_MAY_LANMAN 0x00010 449#define CIFSSEC_MAY_PLNTXT 0x00020 450#endif /* weak passwords */ 451#define CIFSSEC_MAY_SEAL 0x00040 /* not supported yet */ 452 453#define CIFSSEC_MUST_SIGN 0x01001 454/* note that only one of the following can be set so the 455result of setting MUST flags more than once will be to 456require use of the stronger protocol */ 457#define CIFSSEC_MUST_NTLM 0x02002 458#define CIFSSEC_MUST_NTLMV2 0x04004 459#define CIFSSEC_MUST_KRB5 0x08008 460#ifdef CONFIG_CIFS_WEAK_PW_HASH 461#define CIFSSEC_MUST_LANMAN 0x10010 462#define CIFSSEC_MUST_PLNTXT 0x20020 463#define CIFSSEC_MASK 0x37037 /* current flags supported if weak */ 464#else 465#define CIFSSEC_MASK 0x07007 /* flags supported if no weak config */ 466#endif /* WEAK_PW_HASH */ 467#define CIFSSEC_MUST_SEAL 0x40040 /* not supported yet */ 468 469#define CIFSSEC_DEF CIFSSEC_MAY_SIGN | CIFSSEC_MAY_NTLM | CIFSSEC_MAY_NTLMV2 470#define CIFSSEC_MAX CIFSSEC_MUST_SIGN | CIFSSEC_MUST_NTLMV2 471/* 472 ***************************************************************** 473 * All constants go here 474 ***************************************************************** 475 */ 476 477#define UID_HASH (16) 478 479/* 480 * Note that ONE module should define _DECLARE_GLOBALS_HERE to cause the 481 * following to be declared. 482 */ 483 484/**************************************************************************** 485 * Locking notes. All updates to global variables and lists should be 486 * protected by spinlocks or semaphores. 487 * 488 * Spinlocks 489 * --------- 490 * GlobalMid_Lock protects: 491 * list operations on pending_mid_q and oplockQ 492 * updates to XID counters, multiplex id and SMB sequence numbers 493 * GlobalSMBSesLock protects: 494 * list operations on tcp and SMB session lists and tCon lists 495 * f_owner.lock protects certain per file struct operations 496 * mapping->page_lock protects certain per page operations 497 * 498 * Semaphores 499 * ---------- 500 * sesSem operations on smb session 501 * tconSem operations on tree connection 502 * fh_sem file handle reconnection operations 503 * 504 ****************************************************************************/ 505 506#ifdef DECLARE_GLOBALS_HERE 507#define GLOBAL_EXTERN 508#else 509#define GLOBAL_EXTERN extern 510#endif 511 512/* 513 * The list of servers that did not respond with NT LM 0.12. 514 * This list helps improve performance and eliminate the messages indicating 515 * that we had a communications error talking to the server in this list. 516 */ 517/* Feature not supported */ 518/* GLOBAL_EXTERN struct servers_not_supported *NotSuppList; */ 519 520/* 521 * The following is a hash table of all the users we know about. 522 */ 523GLOBAL_EXTERN struct smbUidInfo *GlobalUidList[UID_HASH]; 524 525/* GLOBAL_EXTERN struct list_head GlobalServerList; BB not implemented yet */ 526GLOBAL_EXTERN struct list_head GlobalSMBSessionList; 527GLOBAL_EXTERN struct list_head GlobalTreeConnectionList; 528GLOBAL_EXTERN rwlock_t GlobalSMBSeslock; /* protects list inserts on 3 above */ 529 530GLOBAL_EXTERN struct list_head GlobalOplock_Q; 531 532/* Outstanding dir notify requests */ 533GLOBAL_EXTERN struct list_head GlobalDnotifyReqList; 534/* DirNotify response queue */ 535GLOBAL_EXTERN struct list_head GlobalDnotifyRsp_Q; 536 537/* 538 * Global transaction id (XID) information 539 */ 540GLOBAL_EXTERN unsigned int GlobalCurrentXid; /* protected by GlobalMid_Sem */ 541GLOBAL_EXTERN unsigned int GlobalTotalActiveXid; /* prot by GlobalMid_Sem */ 542GLOBAL_EXTERN unsigned int GlobalMaxActiveXid; /* prot by GlobalMid_Sem */ 543GLOBAL_EXTERN spinlock_t GlobalMid_Lock; /* protects above & list operations */ 544 /* on midQ entries */ 545GLOBAL_EXTERN char Local_System_Name[15]; 546 547/* 548 * Global counters, updated atomically 549 */ 550GLOBAL_EXTERN atomic_t sesInfoAllocCount; 551GLOBAL_EXTERN atomic_t tconInfoAllocCount; 552GLOBAL_EXTERN atomic_t tcpSesAllocCount; 553GLOBAL_EXTERN atomic_t tcpSesReconnectCount; 554GLOBAL_EXTERN atomic_t tconInfoReconnectCount; 555 556/* Various Debug counters to remove someday (BB) */ 557GLOBAL_EXTERN atomic_t bufAllocCount; /* current number allocated */ 558#ifdef CONFIG_CIFS_STATS2 559GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */ 560GLOBAL_EXTERN atomic_t totSmBufAllocCount; 561#endif 562GLOBAL_EXTERN atomic_t smBufAllocCount; 563GLOBAL_EXTERN atomic_t midCount; 564 565/* Misc globals */ 566GLOBAL_EXTERN unsigned int multiuser_mount; /* if enabled allows new sessions 567 to be established on existing mount if we 568 have the uid/password or Kerberos credential 569 or equivalent for current user */ 570GLOBAL_EXTERN unsigned int oplockEnabled; 571GLOBAL_EXTERN unsigned int experimEnabled; 572GLOBAL_EXTERN unsigned int lookupCacheEnabled; 573GLOBAL_EXTERN unsigned int extended_security; /* if on, session setup sent 574 with more secure ntlmssp2 challenge/resp */ 575GLOBAL_EXTERN unsigned int sign_CIFS_PDUs; /* enable smb packet signing */ 576GLOBAL_EXTERN unsigned int linuxExtEnabled;/*enable Linux/Unix CIFS extensions*/ 577GLOBAL_EXTERN unsigned int CIFSMaxBufSize; /* max size not including hdr */ 578GLOBAL_EXTERN unsigned int cifs_min_rcv; /* min size of big ntwrk buf pool */ 579GLOBAL_EXTERN unsigned int cifs_min_small; /* min size of small buf pool */ 580GLOBAL_EXTERN unsigned int cifs_max_pending; /* MAX requests at once to server*/ 581