]>
Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * fs/cifs/misc.c | |
3 | * | |
4 | * Copyright (C) International Business Machines Corp., 2002,2004 | |
5 | * Author(s): Steve French (sfrench@us.ibm.com) | |
6 | * | |
7 | * This library is free software; you can redistribute it and/or modify | |
8 | * it under the terms of the GNU Lesser General Public License as published | |
9 | * by the Free Software Foundation; either version 2.1 of the License, or | |
10 | * (at your option) any later version. | |
11 | * | |
12 | * This library is distributed in the hope that it will be useful, | |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See | |
15 | * the GNU Lesser General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU Lesser General Public License | |
18 | * along with this library; if not, write to the Free Software | |
19 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
20 | */ | |
21 | ||
22 | #include <linux/slab.h> | |
23 | #include <linux/ctype.h> | |
24 | #include <linux/mempool.h> | |
25 | #include "cifspdu.h" | |
26 | #include "cifsglob.h" | |
27 | #include "cifsproto.h" | |
28 | #include "cifs_debug.h" | |
29 | #include "smberr.h" | |
30 | #include "nterr.h" | |
31 | ||
32 | extern mempool_t *cifs_sm_req_poolp; | |
33 | extern mempool_t *cifs_req_poolp; | |
34 | extern struct task_struct * oplockThread; | |
35 | ||
36 | static __u16 GlobalMid; /* multiplex id - rotating counter */ | |
37 | ||
38 | /* The xid serves as a useful identifier for each incoming vfs request, | |
39 | in a similar way to the mid which is useful to track each sent smb, | |
40 | and CurrentXid can also provide a running counter (although it | |
41 | will eventually wrap past zero) of the total vfs operations handled | |
42 | since the cifs fs was mounted */ | |
43 | ||
44 | unsigned int | |
45 | _GetXid(void) | |
46 | { | |
47 | unsigned int xid; | |
48 | ||
49 | spin_lock(&GlobalMid_Lock); | |
50 | GlobalTotalActiveXid++; | |
51 | if (GlobalTotalActiveXid > GlobalMaxActiveXid) | |
52 | GlobalMaxActiveXid = GlobalTotalActiveXid; /* keep high water mark for number of simultaneous vfs ops in our filesystem */ | |
53 | xid = GlobalCurrentXid++; | |
54 | spin_unlock(&GlobalMid_Lock); | |
55 | return xid; | |
56 | } | |
57 | ||
58 | void | |
59 | _FreeXid(unsigned int xid) | |
60 | { | |
61 | spin_lock(&GlobalMid_Lock); | |
62 | /* if(GlobalTotalActiveXid == 0) | |
63 | BUG(); */ | |
64 | GlobalTotalActiveXid--; | |
65 | spin_unlock(&GlobalMid_Lock); | |
66 | } | |
67 | ||
68 | struct cifsSesInfo * | |
69 | sesInfoAlloc(void) | |
70 | { | |
71 | struct cifsSesInfo *ret_buf; | |
72 | ||
73 | ret_buf = | |
74 | (struct cifsSesInfo *) kmalloc(sizeof (struct cifsSesInfo), | |
75 | GFP_KERNEL); | |
76 | if (ret_buf) { | |
77 | memset(ret_buf, 0, sizeof (struct cifsSesInfo)); | |
78 | write_lock(&GlobalSMBSeslock); | |
79 | atomic_inc(&sesInfoAllocCount); | |
80 | ret_buf->status = CifsNew; | |
81 | list_add(&ret_buf->cifsSessionList, &GlobalSMBSessionList); | |
82 | init_MUTEX(&ret_buf->sesSem); | |
83 | write_unlock(&GlobalSMBSeslock); | |
84 | } | |
85 | return ret_buf; | |
86 | } | |
87 | ||
88 | void | |
89 | sesInfoFree(struct cifsSesInfo *buf_to_free) | |
90 | { | |
91 | if (buf_to_free == NULL) { | |
92 | cFYI(1, ("Null buffer passed to sesInfoFree")); | |
93 | return; | |
94 | } | |
95 | ||
96 | write_lock(&GlobalSMBSeslock); | |
97 | atomic_dec(&sesInfoAllocCount); | |
98 | list_del(&buf_to_free->cifsSessionList); | |
99 | write_unlock(&GlobalSMBSeslock); | |
100 | if (buf_to_free->serverOS) | |
101 | kfree(buf_to_free->serverOS); | |
102 | if (buf_to_free->serverDomain) | |
103 | kfree(buf_to_free->serverDomain); | |
104 | if (buf_to_free->serverNOS) | |
105 | kfree(buf_to_free->serverNOS); | |
106 | if (buf_to_free->password) | |
107 | kfree(buf_to_free->password); | |
108 | kfree(buf_to_free); | |
109 | } | |
110 | ||
111 | struct cifsTconInfo * | |
112 | tconInfoAlloc(void) | |
113 | { | |
114 | struct cifsTconInfo *ret_buf; | |
115 | ret_buf = | |
116 | (struct cifsTconInfo *) kmalloc(sizeof (struct cifsTconInfo), | |
117 | GFP_KERNEL); | |
118 | if (ret_buf) { | |
119 | memset(ret_buf, 0, sizeof (struct cifsTconInfo)); | |
120 | write_lock(&GlobalSMBSeslock); | |
121 | atomic_inc(&tconInfoAllocCount); | |
122 | list_add(&ret_buf->cifsConnectionList, | |
123 | &GlobalTreeConnectionList); | |
124 | ret_buf->tidStatus = CifsNew; | |
125 | INIT_LIST_HEAD(&ret_buf->openFileList); | |
126 | init_MUTEX(&ret_buf->tconSem); | |
127 | #ifdef CONFIG_CIFS_STATS | |
128 | spin_lock_init(&ret_buf->stat_lock); | |
129 | #endif | |
130 | write_unlock(&GlobalSMBSeslock); | |
131 | } | |
132 | return ret_buf; | |
133 | } | |
134 | ||
135 | void | |
136 | tconInfoFree(struct cifsTconInfo *buf_to_free) | |
137 | { | |
138 | if (buf_to_free == NULL) { | |
139 | cFYI(1, ("Null buffer passed to tconInfoFree")); | |
140 | return; | |
141 | } | |
142 | write_lock(&GlobalSMBSeslock); | |
143 | atomic_dec(&tconInfoAllocCount); | |
144 | list_del(&buf_to_free->cifsConnectionList); | |
145 | write_unlock(&GlobalSMBSeslock); | |
146 | if (buf_to_free->nativeFileSystem) | |
147 | kfree(buf_to_free->nativeFileSystem); | |
148 | kfree(buf_to_free); | |
149 | } | |
150 | ||
151 | struct smb_hdr * | |
152 | cifs_buf_get(void) | |
153 | { | |
154 | struct smb_hdr *ret_buf = NULL; | |
155 | ||
156 | /* We could use negotiated size instead of max_msgsize - | |
157 | but it may be more efficient to always alloc same size | |
158 | albeit slightly larger than necessary and maxbuffersize | |
159 | defaults to this and can not be bigger */ | |
160 | ret_buf = | |
161 | (struct smb_hdr *) mempool_alloc(cifs_req_poolp, SLAB_KERNEL | SLAB_NOFS); | |
162 | ||
163 | /* clear the first few header bytes */ | |
164 | /* for most paths, more is cleared in header_assemble */ | |
165 | if (ret_buf) { | |
166 | memset(ret_buf, 0, sizeof(struct smb_hdr) + 3); | |
167 | atomic_inc(&bufAllocCount); | |
168 | } | |
169 | ||
170 | return ret_buf; | |
171 | } | |
172 | ||
173 | void | |
174 | cifs_buf_release(void *buf_to_free) | |
175 | { | |
176 | ||
177 | if (buf_to_free == NULL) { | |
178 | /* cFYI(1, ("Null buffer passed to cifs_buf_release"));*/ | |
179 | return; | |
180 | } | |
181 | mempool_free(buf_to_free,cifs_req_poolp); | |
182 | ||
183 | atomic_dec(&bufAllocCount); | |
184 | return; | |
185 | } | |
186 | ||
187 | struct smb_hdr * | |
188 | cifs_small_buf_get(void) | |
189 | { | |
190 | struct smb_hdr *ret_buf = NULL; | |
191 | ||
192 | /* We could use negotiated size instead of max_msgsize - | |
193 | but it may be more efficient to always alloc same size | |
194 | albeit slightly larger than necessary and maxbuffersize | |
195 | defaults to this and can not be bigger */ | |
196 | ret_buf = | |
197 | (struct smb_hdr *) mempool_alloc(cifs_sm_req_poolp, SLAB_KERNEL | SLAB_NOFS); | |
198 | if (ret_buf) { | |
199 | /* No need to clear memory here, cleared in header assemble */ | |
200 | /* memset(ret_buf, 0, sizeof(struct smb_hdr) + 27);*/ | |
201 | atomic_inc(&smBufAllocCount); | |
202 | } | |
203 | return ret_buf; | |
204 | } | |
205 | ||
206 | void | |
207 | cifs_small_buf_release(void *buf_to_free) | |
208 | { | |
209 | ||
210 | if (buf_to_free == NULL) { | |
211 | cFYI(1, ("Null buffer passed to cifs_small_buf_release")); | |
212 | return; | |
213 | } | |
214 | mempool_free(buf_to_free,cifs_sm_req_poolp); | |
215 | ||
216 | atomic_dec(&smBufAllocCount); | |
217 | return; | |
218 | } | |
219 | ||
220 | void | |
221 | header_assemble(struct smb_hdr *buffer, char smb_command /* command */ , | |
222 | const struct cifsTconInfo *treeCon, int word_count | |
223 | /* length of fixed section (word count) in two byte units */) | |
224 | { | |
225 | struct list_head* temp_item; | |
226 | struct cifsSesInfo * ses; | |
227 | char *temp = (char *) buffer; | |
228 | ||
229 | memset(temp,0,MAX_CIFS_HDR_SIZE); | |
230 | ||
231 | buffer->smb_buf_length = | |
232 | (2 * word_count) + sizeof (struct smb_hdr) - | |
233 | 4 /* RFC 1001 length field does not count */ + | |
234 | 2 /* for bcc field itself */ ; | |
235 | /* Note that this is the only network field that has to be converted to big endian and it is done just before we send it */ | |
236 | ||
237 | buffer->Protocol[0] = 0xFF; | |
238 | buffer->Protocol[1] = 'S'; | |
239 | buffer->Protocol[2] = 'M'; | |
240 | buffer->Protocol[3] = 'B'; | |
241 | buffer->Command = smb_command; | |
242 | buffer->Flags = 0x00; /* case sensitive */ | |
243 | buffer->Flags2 = SMBFLG2_KNOWS_LONG_NAMES; | |
244 | buffer->Pid = cpu_to_le16((__u16)current->tgid); | |
245 | buffer->PidHigh = cpu_to_le16((__u16)(current->tgid >> 16)); | |
246 | spin_lock(&GlobalMid_Lock); | |
247 | GlobalMid++; | |
248 | buffer->Mid = GlobalMid; | |
249 | spin_unlock(&GlobalMid_Lock); | |
250 | if (treeCon) { | |
251 | buffer->Tid = treeCon->tid; | |
252 | if (treeCon->ses) { | |
253 | if (treeCon->ses->capabilities & CAP_UNICODE) | |
254 | buffer->Flags2 |= SMBFLG2_UNICODE; | |
255 | if (treeCon->ses->capabilities & CAP_STATUS32) { | |
256 | buffer->Flags2 |= SMBFLG2_ERR_STATUS; | |
257 | } | |
258 | ||
259 | buffer->Uid = treeCon->ses->Suid; /* always in LE format */ | |
260 | if(multiuser_mount != 0) { | |
261 | /* For the multiuser case, there are few obvious technically */ | |
262 | /* possible mechanisms to match the local linux user (uid) */ | |
263 | /* to a valid remote smb user (smb_uid): */ | |
264 | /* 1) Query Winbind (or other local pam/nss daemon */ | |
265 | /* for userid/password/logon_domain or credential */ | |
266 | /* 2) Query Winbind for uid to sid to username mapping */ | |
267 | /* and see if we have a matching password for existing*/ | |
268 | /* session for that user perhas getting password by */ | |
269 | /* adding a new pam_cifs module that stores passwords */ | |
270 | /* so that the cifs vfs can get at that for all logged*/ | |
271 | /* on users */ | |
272 | /* 3) (Which is the mechanism we have chosen) */ | |
273 | /* Search through sessions to the same server for a */ | |
274 | /* a match on the uid that was passed in on mount */ | |
275 | /* with the current processes uid (or euid?) and use */ | |
276 | /* that smb uid. If no existing smb session for */ | |
277 | /* that uid found, use the default smb session ie */ | |
278 | /* the smb session for the volume mounted which is */ | |
279 | /* the same as would be used if the multiuser mount */ | |
280 | /* flag were disabled. */ | |
281 | ||
282 | /* BB Add support for establishing new tCon and SMB Session */ | |
283 | /* with userid/password pairs found on the smb session */ | |
284 | /* for other target tcp/ip addresses BB */ | |
285 | if(current->uid != treeCon->ses->linux_uid) { | |
286 | cFYI(1,("Multiuser mode and UID did not match tcon uid ")); | |
287 | read_lock(&GlobalSMBSeslock); | |
288 | list_for_each(temp_item, &GlobalSMBSessionList) { | |
289 | ses = list_entry(temp_item, struct cifsSesInfo, cifsSessionList); | |
290 | if(ses->linux_uid == current->uid) { | |
291 | if(ses->server == treeCon->ses->server) { | |
292 | cFYI(1,("found matching uid substitute right smb_uid")); | |
293 | buffer->Uid = ses->Suid; | |
294 | break; | |
295 | } else { | |
296 | /* BB eventually call cifs_setup_session here */ | |
297 | cFYI(1,("local UID found but smb sess with this server does not exist")); | |
298 | } | |
299 | } | |
300 | } | |
301 | read_unlock(&GlobalSMBSeslock); | |
302 | } | |
303 | } | |
304 | } | |
305 | if (treeCon->Flags & SMB_SHARE_IS_IN_DFS) | |
306 | buffer->Flags2 |= SMBFLG2_DFS; | |
307 | if((treeCon->ses) && (treeCon->ses->server)) | |
308 | if(treeCon->ses->server->secMode & | |
309 | (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) | |
310 | buffer->Flags2 |= SMBFLG2_SECURITY_SIGNATURE; | |
311 | } | |
312 | ||
313 | /* endian conversion of flags is now done just before sending */ | |
314 | buffer->WordCount = (char) word_count; | |
315 | return; | |
316 | } | |
317 | ||
318 | int | |
319 | checkSMBhdr(struct smb_hdr *smb, __u16 mid) | |
320 | { | |
321 | /* Make sure that this really is an SMB, that it is a response, | |
322 | and that the message ids match */ | |
323 | if ((*(__le32 *) smb->Protocol == cpu_to_le32(0x424d53ff)) && | |
324 | (mid == smb->Mid)) { | |
325 | if(smb->Flags & SMBFLG_RESPONSE) | |
326 | return 0; | |
327 | else { | |
328 | /* only one valid case where server sends us request */ | |
329 | if(smb->Command == SMB_COM_LOCKING_ANDX) | |
330 | return 0; | |
331 | else | |
332 | cERROR(1, ("Rcvd Request not response ")); | |
333 | } | |
334 | } else { /* bad signature or mid */ | |
335 | if (*(__le32 *) smb->Protocol != cpu_to_le32(0x424d53ff)) | |
336 | cERROR(1, | |
337 | ("Bad protocol string signature header %x ", | |
338 | *(unsigned int *) smb->Protocol)); | |
339 | if (mid != smb->Mid) | |
340 | cERROR(1, ("Mids do not match")); | |
341 | } | |
342 | cERROR(1, ("bad smb detected. The Mid=%d", smb->Mid)); | |
343 | return 1; | |
344 | } | |
345 | ||
346 | int | |
347 | checkSMB(struct smb_hdr *smb, __u16 mid, int length) | |
348 | { | |
349 | __u32 len = be32_to_cpu(smb->smb_buf_length); | |
350 | cFYI(0, | |
351 | ("Entering checkSMB with Length: %x, smb_buf_length: %x ", | |
352 | length, len)); | |
353 | if (((unsigned int)length < 2 + sizeof (struct smb_hdr)) || | |
354 | (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4)) { | |
355 | if ((unsigned int)length < 2 + sizeof (struct smb_hdr)) { | |
356 | if (((unsigned int)length >= | |
357 | sizeof (struct smb_hdr) - 1) | |
358 | && (smb->Status.CifsError != 0)) { | |
359 | smb->WordCount = 0; | |
360 | return 0; /* some error cases do not return wct and bcc */ | |
361 | } else { | |
362 | cERROR(1, ("Length less than smb header size")); | |
363 | } | |
364 | ||
365 | } | |
366 | if (len > CIFSMaxBufSize + MAX_CIFS_HDR_SIZE - 4) | |
367 | cERROR(1, | |
368 | ("smb_buf_length greater than MaxBufSize")); | |
369 | cERROR(1, | |
370 | ("bad smb detected. Illegal length. The mid=%d", | |
371 | smb->Mid)); | |
372 | return 1; | |
373 | } | |
374 | ||
375 | if (checkSMBhdr(smb, mid)) | |
376 | return 1; | |
377 | ||
378 | if ((4 + len != smbCalcSize(smb)) | |
379 | || (4 + len != (unsigned int)length)) { | |
380 | return 0; | |
381 | } else { | |
382 | cERROR(1, ("smbCalcSize %x ", smbCalcSize(smb))); | |
383 | cERROR(1, | |
384 | ("bad smb size detected. The Mid=%d", smb->Mid)); | |
385 | return 1; | |
386 | } | |
387 | } | |
388 | int | |
389 | is_valid_oplock_break(struct smb_hdr *buf) | |
390 | { | |
391 | struct smb_com_lock_req * pSMB = (struct smb_com_lock_req *)buf; | |
392 | struct list_head *tmp; | |
393 | struct list_head *tmp1; | |
394 | struct cifsTconInfo *tcon; | |
395 | struct cifsFileInfo *netfile; | |
396 | ||
397 | cFYI(1,("Checking for oplock break or dnotify response")); | |
398 | if((pSMB->hdr.Command == SMB_COM_NT_TRANSACT) && | |
399 | (pSMB->hdr.Flags & SMBFLG_RESPONSE)) { | |
400 | struct smb_com_transaction_change_notify_rsp * pSMBr = | |
401 | (struct smb_com_transaction_change_notify_rsp *)buf; | |
402 | struct file_notify_information * pnotify; | |
403 | __u32 data_offset = 0; | |
404 | if(pSMBr->ByteCount > sizeof(struct file_notify_information)) { | |
405 | data_offset = le32_to_cpu(pSMBr->DataOffset); | |
406 | ||
407 | pnotify = (struct file_notify_information *)((char *)&pSMBr->hdr.Protocol | |
408 | + data_offset); | |
409 | cFYI(1,("dnotify on %s with action: 0x%x",pnotify->FileName, | |
410 | pnotify->Action)); /* BB removeme BB */ | |
411 | /* cifs_dump_mem("Received notify Data is: ",buf,sizeof(struct smb_hdr)+60); */ | |
412 | return TRUE; | |
413 | } | |
414 | if(pSMBr->hdr.Status.CifsError) { | |
415 | cFYI(1,("notify err 0x%d",pSMBr->hdr.Status.CifsError)); | |
416 | return TRUE; | |
417 | } | |
418 | return FALSE; | |
419 | } | |
420 | if(pSMB->hdr.Command != SMB_COM_LOCKING_ANDX) | |
421 | return FALSE; | |
422 | if(pSMB->hdr.Flags & SMBFLG_RESPONSE) { | |
423 | /* no sense logging error on invalid handle on oplock | |
424 | break - harmless race between close request and oplock | |
425 | break response is expected from time to time writing out | |
426 | large dirty files cached on the client */ | |
427 | if ((NT_STATUS_INVALID_HANDLE) == | |
428 | le32_to_cpu(pSMB->hdr.Status.CifsError)) { | |
429 | cFYI(1,("invalid handle on oplock break")); | |
430 | return TRUE; | |
431 | } else if (ERRbadfid == | |
432 | le16_to_cpu(pSMB->hdr.Status.DosError.Error)) { | |
433 | return TRUE; | |
434 | } else { | |
435 | return FALSE; /* on valid oplock brk we get "request" */ | |
436 | } | |
437 | } | |
438 | if(pSMB->hdr.WordCount != 8) | |
439 | return FALSE; | |
440 | ||
441 | cFYI(1,(" oplock type 0x%d level 0x%d",pSMB->LockType,pSMB->OplockLevel)); | |
442 | if(!(pSMB->LockType & LOCKING_ANDX_OPLOCK_RELEASE)) | |
443 | return FALSE; | |
444 | ||
445 | /* look up tcon based on tid & uid */ | |
446 | read_lock(&GlobalSMBSeslock); | |
447 | list_for_each(tmp, &GlobalTreeConnectionList) { | |
448 | tcon = list_entry(tmp, struct cifsTconInfo, cifsConnectionList); | |
449 | if (tcon->tid == buf->Tid) { | |
450 | #ifdef CONFIG_CIFS_STATS | |
451 | atomic_inc(&tcon->num_oplock_brks); | |
452 | #endif | |
453 | list_for_each(tmp1,&tcon->openFileList){ | |
454 | netfile = list_entry(tmp1,struct cifsFileInfo,tlist); | |
455 | if(pSMB->Fid == netfile->netfid) { | |
456 | struct cifsInodeInfo *pCifsInode; | |
457 | read_unlock(&GlobalSMBSeslock); | |
458 | cFYI(1,("Matching file id, processing oplock break")); | |
459 | pCifsInode = | |
460 | CIFS_I(netfile->pInode); | |
461 | pCifsInode->clientCanCacheAll = FALSE; | |
462 | if(pSMB->OplockLevel == 0) | |
463 | pCifsInode->clientCanCacheRead = FALSE; | |
464 | pCifsInode->oplockPending = TRUE; | |
465 | AllocOplockQEntry(netfile->pInode, netfile->netfid, tcon); | |
466 | cFYI(1,("about to wake up oplock thd")); | |
467 | wake_up_process(oplockThread); | |
468 | return TRUE; | |
469 | } | |
470 | } | |
471 | read_unlock(&GlobalSMBSeslock); | |
472 | cFYI(1,("No matching file for oplock break on connection")); | |
473 | return TRUE; | |
474 | } | |
475 | } | |
476 | read_unlock(&GlobalSMBSeslock); | |
477 | cFYI(1,("Can not process oplock break for non-existent connection")); | |
478 | return TRUE; | |
479 | } | |
480 | ||
481 | void | |
482 | dump_smb(struct smb_hdr *smb_buf, int smb_buf_length) | |
483 | { | |
484 | int i, j; | |
485 | char debug_line[17]; | |
486 | unsigned char *buffer; | |
487 | ||
488 | if (traceSMB == 0) | |
489 | return; | |
490 | ||
491 | buffer = (unsigned char *) smb_buf; | |
492 | for (i = 0, j = 0; i < smb_buf_length; i++, j++) { | |
493 | if (i % 8 == 0) { /* we have reached the beginning of line */ | |
494 | printk(KERN_DEBUG "| "); | |
495 | j = 0; | |
496 | } | |
497 | printk("%0#4x ", buffer[i]); | |
498 | debug_line[2 * j] = ' '; | |
499 | if (isprint(buffer[i])) | |
500 | debug_line[1 + (2 * j)] = buffer[i]; | |
501 | else | |
502 | debug_line[1 + (2 * j)] = '_'; | |
503 | ||
504 | if (i % 8 == 7) { /* we have reached end of line, time to print ascii */ | |
505 | debug_line[16] = 0; | |
506 | printk(" | %s\n", debug_line); | |
507 | } | |
508 | } | |
509 | for (; j < 8; j++) { | |
510 | printk(" "); | |
511 | debug_line[2 * j] = ' '; | |
512 | debug_line[1 + (2 * j)] = ' '; | |
513 | } | |
514 | printk( " | %s\n", debug_line); | |
515 | return; | |
516 | } | |
6a0b4824 SF |
517 | |
518 | #ifdef CONFIG_CIFS_EXPERIMENTAL | |
519 | /* Windows maps these to the user defined 16 bit Unicode range since they are | |
520 | reserved symbols (along with \ and /), otherwise illegal to store | |
521 | in filenames in NTFS */ | |
522 | #define UNI_ASTERIK cpu_to_le16('*' + 0xF000) | |
523 | #define UNI_QUESTION cpu_to_le16('?' + 0xF000) | |
524 | #define UNI_COLON cpu_to_le16(':' + 0xF000) | |
525 | #define UNI_GRTRTHAN cpu_to_le16('>' + 0xF000) | |
526 | #define UNI_LESSTHAN cpu_to_le16('<' + 0xF000) | |
527 | #define UNI_PIPE cpu_to_le16('|' + 0xF000) | |
528 | #define UNI_SLASH cpu_to_le16('\\' + 0xF000) | |
529 | ||
530 | /* Convert 16 bit Unicode pathname from wire format to string in current code | |
531 | page. Conversion may involve remapping up the seven characters that are | |
532 | only legal in POSIX-like OS (if they are present in the string). Path | |
533 | names are little endian 16 bit Unicode on the wire */ | |
534 | int | |
535 | cifs_convertUCSpath(char *target, const __le16 * source, int maxlen, | |
536 | const struct nls_table * cp) | |
537 | { | |
538 | int i,j,len; | |
539 | wchar_t src_char; | |
540 | ||
541 | for(i = 0, j = 0; i < maxlen; i++) { | |
542 | src_char = le16_to_cpu(source[i]); | |
543 | switch (src_char) { | |
544 | case 0: | |
545 | goto cUCS_out; /* BB check this BB */ | |
546 | case UNI_COLON: | |
547 | target[j] = ':'; | |
548 | break; | |
549 | case UNI_ASTERIK: | |
550 | target[j] = '*'; | |
551 | break; | |
552 | case UNI_QUESTION: | |
553 | target[j] = '?'; | |
554 | break; | |
555 | case UNI_SLASH: | |
556 | target[j] = '\\'; /* BB check this - is there risk here of converting path sep BB */ | |
557 | break; | |
558 | case UNI_PIPE: | |
559 | target[j] = '|'; | |
560 | break; | |
561 | case UNI_GRTRTHAN: | |
562 | target[j] = '>'; | |
563 | break; | |
564 | case UNI_LESSTHAN: | |
565 | target[j] = '<'; | |
566 | default: | |
567 | len = cp->uni2char(src_char, &target[j], | |
568 | NLS_MAX_CHARSET_SIZE); | |
569 | if(len > 0) { | |
570 | j += len; | |
571 | continue; | |
572 | } else { | |
573 | target[j] = '?'; | |
574 | } | |
575 | } | |
576 | j++; | |
577 | /* check to make sure we do not overrun callers allocated temp buffer */ | |
578 | if(j >= (2 * NAME_MAX)) | |
579 | break; | |
580 | } | |
581 | cUCS_out: | |
582 | target[j] = 0; | |
583 | return j; | |
584 | } | |
585 | #endif /* CIFS_EXPERIMENTAL */ |