开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
ioctl.c
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：16k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

ioctl.c：源码内容
  1. /*
  2.  *  ioctl.c
  3.  *
  4.  *  Copyright (C) 1995, 1996 by Volker Lendecke
  5.  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
  6.  *  Modified 1998, 1999 Wolfram Pienkoss for NLS
  7.  *
  8.  */
  10. #include <linux/config.h>
  12. #include <asm/uaccess.h>
  13. #include <linux/errno.h>
  14. #include <linux/fs.h>
  15. #include <linux/ioctl.h>
  16. #include <linux/sched.h>
  17. #include <linux/mm.h>
  18. #include <linux/highuid.h>
  19. #include <linux/vmalloc.h>
  21. #include <linux/ncp_fs.h>
  23. #include "ncplib_kernel.h"
  25. /* maximum limit for ncp_objectname_ioctl */
  26. #define NCP_OBJECT_NAME_MAX_LEN 4096
  27. /* maximum limit for ncp_privatedata_ioctl */
  28. #define NCP_PRIVATE_DATA_MAX_LEN 8192
  29. /* maximum negotiable packet size */
  30. #define NCP_PACKET_SIZE_INTERNAL 65536
  32. int ncp_ioctl(struct inode *inode, struct file *filp,
  33.       unsigned int cmd, unsigned long arg)
  34. {
  35. struct ncp_server *server = NCP_SERVER(inode);
  36. int result;
  37. struct ncp_ioctl_request request;
  38. char* bouncebuffer;
  40. switch (cmd) {
  41. case NCP_IOC_NCPREQUEST:
  43. if ((permission(inode, MAY_WRITE) != 0)
  44.     && (current->uid != server->m.mounted_uid)) {
  45. return -EACCES;
  46. }
  47. if (copy_from_user(&request, (struct ncp_ioctl_request *) arg,
  48.        sizeof(request)))
  49. return -EFAULT;
  51. if ((request.function > 255)
  52.     || (request.size >
  53.   NCP_PACKET_SIZE - sizeof(struct ncp_request_header))) {
  54. return -EINVAL;
  55. }
  56. bouncebuffer = vmalloc(NCP_PACKET_SIZE_INTERNAL);
  57. if (!bouncebuffer)
  58. return -ENOMEM;
  59. if (copy_from_user(bouncebuffer, request.data, request.size)) {
  60. vfree(bouncebuffer);
  61. return -EFAULT;
  62. }
  63. ncp_lock_server(server);
  65. /* FIXME: We hack around in the server's structures
  66.    here to be able to use ncp_request */
  68. server->has_subfunction = 0;
  69. server->current_size = request.size;
  70. memcpy(server->packet, bouncebuffer, request.size);
  72. result = ncp_request2(server, request.function, 
  73. bouncebuffer, NCP_PACKET_SIZE_INTERNAL);
  74. if (result < 0)
  75. result = -EIO;
  76. else
  77. result = server->reply_size;
  78. ncp_unlock_server(server);
  79. DPRINTK("ncp_ioctl: copy %d bytesn",
  80. result);
  81. if (result >= 0)
  82. if (copy_to_user(request.data, bouncebuffer, result))
  83. result = -EFAULT;
  84. vfree(bouncebuffer);
  85. return result;
  87. case NCP_IOC_CONN_LOGGED_IN:
  89. if (!capable(CAP_SYS_ADMIN))
  90. return -EACCES;
  91. if (!(server->m.int_flags & NCP_IMOUNT_LOGGEDIN_POSSIBLE))
  92. return -EINVAL;
  93. if (server->root_setuped)
  94. return -EBUSY;
  95. server->root_setuped = 1;
  96. return ncp_conn_logged_in(inode->i_sb);
  98. case NCP_IOC_GET_FS_INFO:
  99. {
  100. struct ncp_fs_info info;
  102. if ((permission(inode, MAY_WRITE) != 0)
  103.     && (current->uid != server->m.mounted_uid)) {
  104. return -EACCES;
  105. }
  106. if (copy_from_user(&info, (struct ncp_fs_info *) arg, 
  107. sizeof(info)))
  108. return -EFAULT;
  110. if (info.version != NCP_GET_FS_INFO_VERSION) {
  111. DPRINTK("info.version invalid: %dn", info.version);
  112. return -EINVAL;
  113. }
  114. /* TODO: info.addr = server->m.serv_addr; */
  115. info.mounted_uid = NEW_TO_OLD_UID(server->m.mounted_uid);
  116. info.connection = server->connection;
  117. info.buffer_size = server->buffer_size;
  118. info.volume_number = NCP_FINFO(inode)->volNumber;
  119. info.directory_id = NCP_FINFO(inode)->DosDirNum;
  121. if (copy_to_user((struct ncp_fs_info *) arg, &info, 
  122. sizeof(info))) return -EFAULT;
  123. return 0;
  124. }
  126. case NCP_IOC_GET_FS_INFO_V2:
  127. {
  128. struct ncp_fs_info_v2 info2;
  130. if ((permission(inode, MAY_WRITE) != 0)
  131.     && (current->uid != server->m.mounted_uid)) {
  132. return -EACCES;
  133. }
  134. if (copy_from_user(&info2, (struct ncp_fs_info_v2 *) arg, 
  135. sizeof(info2)))
  136. return -EFAULT;
  138. if (info2.version != NCP_GET_FS_INFO_VERSION_V2) {
  139. DPRINTK("info.version invalid: %dn", info2.version);
  140. return -EINVAL;
  141. }
  142. info2.mounted_uid   = server->m.mounted_uid;
  143. info2.connection    = server->connection;
  144. info2.buffer_size   = server->buffer_size;
  145. info2.volume_number = NCP_FINFO(inode)->volNumber;
  146. info2.directory_id  = NCP_FINFO(inode)->DosDirNum;
  147. info2.dummy1 = info2.dummy2 = info2.dummy3 = 0;
  149. if (copy_to_user((struct ncp_fs_info_v2 *) arg, &info2, 
  150. sizeof(info2))) return -EFAULT;
  151. return 0;
  152. }
  154. case NCP_IOC_GETMOUNTUID2:
  155. {
  156. unsigned long tmp = server->m.mounted_uid;
  158. if (   (permission(inode, MAY_READ) != 0)
  159.     && (current->uid != server->m.mounted_uid))
  160. {
  161. return -EACCES;
  162. }
  163. if (put_user(tmp, (unsigned long*) arg)) 
  164. return -EFAULT;
  165. return 0;
  166. }
  168. case NCP_IOC_GETROOT:
  169. {
  170. struct ncp_setroot_ioctl sr;
  172. if (   (permission(inode, MAY_READ) != 0)
  173.     && (current->uid != server->m.mounted_uid))
  174. {
  175. return -EACCES;
  176. }
  177. if (server->m.mounted_vol[0]) {
  178. struct dentry* dentry = inode->i_sb->s_root;
  180. if (dentry) {
  181. struct inode* inode = dentry->d_inode;
  183. if (inode) {
  184. sr.volNumber = NCP_FINFO(inode)->volNumber;
  185. sr.dirEntNum = NCP_FINFO(inode)->dirEntNum;
  186. sr.namespace = server->name_space[sr.volNumber];
  187. } else
  188. DPRINTK("ncpfs: s_root->d_inode==NULLn");
  189. } else
  190. DPRINTK("ncpfs: s_root==NULLn");
  191. } else {
  192. sr.volNumber = -1;
  193. sr.namespace = 0;
  194. sr.dirEntNum = 0;
  195. }
  196. if (copy_to_user((struct ncp_setroot_ioctl*)arg, 
  197.        &sr, 
  198.   sizeof(sr))) return -EFAULT;
  199. return 0;
  200. }
  201. case NCP_IOC_SETROOT:
  202. {
  203. struct ncp_setroot_ioctl sr;
  204. struct nw_info_struct i;
  205. struct dentry* dentry;
  207. if (!capable(CAP_SYS_ADMIN))
  208. {
  209. return -EACCES;
  210. }
  211. if (server->root_setuped) return -EBUSY;
  212. if (copy_from_user(&sr,
  213.    (struct ncp_setroot_ioctl*)arg, 
  214.    sizeof(sr))) return -EFAULT;
  215. if (sr.volNumber < 0) {
  216. server->m.mounted_vol[0] = 0;
  217. i.volNumber = NCP_NUMBER_OF_VOLUMES + 1;
  218. i.dirEntNum = 0;
  219. i.DosDirNum = 0;
  220. } else if (sr.volNumber >= NCP_NUMBER_OF_VOLUMES) {
  221. return -EINVAL;
  222. } else
  223. if (ncp_mount_subdir(server, &i, sr.volNumber,
  224. sr.namespace, sr.dirEntNum))
  225. return -ENOENT;
  227. dentry = inode->i_sb->s_root;
  228. server->root_setuped = 1;
  229. if (dentry) {
  230. struct inode* inode = dentry->d_inode;
  232. if (inode) {
  233. NCP_FINFO(inode)->volNumber = i.volNumber;
  234. NCP_FINFO(inode)->dirEntNum = i.dirEntNum;
  235. NCP_FINFO(inode)->DosDirNum = i.DosDirNum;
  236. } else
  237. DPRINTK("ncpfs: s_root->d_inode==NULLn");
  238. } else
  239. DPRINTK("ncpfs: s_root==NULLn");
  241. return 0;
  242. }
  244. #ifdef CONFIG_NCPFS_PACKET_SIGNING
  245. case NCP_IOC_SIGN_INIT:
  246. if ((permission(inode, MAY_WRITE) != 0)
  247.     && (current->uid != server->m.mounted_uid))
  248. {
  249. return -EACCES;
  250. }
  251. if (arg) {
  252. if (server->sign_wanted)
  253. {
  254. struct ncp_sign_init sign;
  256. if (copy_from_user(&sign, (struct ncp_sign_init *) arg,
  257.       sizeof(sign))) return -EFAULT;
  258. memcpy(server->sign_root,sign.sign_root,8);
  259. memcpy(server->sign_last,sign.sign_last,16);
  260. server->sign_active = 1;
  261. }
  262. /* ignore when signatures not wanted */
  263. } else {
  264. server->sign_active = 0;
  265. }
  266. return 0;
  268.         case NCP_IOC_SIGN_WANTED:
  269. if (   (permission(inode, MAY_READ) != 0)
  270.     && (current->uid != server->m.mounted_uid))
  271. {
  272. return -EACCES;
  273. }
  275.                 if (put_user(server->sign_wanted, (int*) arg))
  276. return -EFAULT;
  277.                 return 0;
  278. case NCP_IOC_SET_SIGN_WANTED:
  279. {
  280. int newstate;
  282. if (   (permission(inode, MAY_WRITE) != 0)
  283.     && (current->uid != server->m.mounted_uid))
  284. {
  285. return -EACCES;
  286. }
  287. /* get only low 8 bits... */
  288. if (get_user(newstate, (unsigned char *) arg))
  289. return -EFAULT;
  290. if (server->sign_active) {
  291. /* cannot turn signatures OFF when active */
  292. if (!newstate) return -EINVAL;
  293. } else {
  294. server->sign_wanted = newstate != 0;
  295. }
  296. return 0;
  297. }
  299. #endif /* CONFIG_NCPFS_PACKET_SIGNING */
  301. #ifdef CONFIG_NCPFS_IOCTL_LOCKING
  302. case NCP_IOC_LOCKUNLOCK:
  303. if (   (permission(inode, MAY_WRITE) != 0)
  304.     && (current->uid != server->m.mounted_uid))
  305. {
  306. return -EACCES;
  307. }
  308. {
  309. struct ncp_lock_ioctl  rqdata;
  310. int result;
  312. if (copy_from_user(&rqdata, (struct ncp_lock_ioctl*)arg,
  313. sizeof(rqdata))) return -EFAULT;
  314. if (rqdata.origin != 0)
  315. return -EINVAL;
  316. /* check for cmd */
  317. switch (rqdata.cmd) {
  318. case NCP_LOCK_EX:
  319. case NCP_LOCK_SH:
  320. if (rqdata.timeout == 0)
  321. rqdata.timeout = NCP_LOCK_DEFAULT_TIMEOUT;
  322. else if (rqdata.timeout > NCP_LOCK_MAX_TIMEOUT)
  323. rqdata.timeout = NCP_LOCK_MAX_TIMEOUT;
  324. break;
  325. case NCP_LOCK_LOG:
  326. rqdata.timeout = NCP_LOCK_DEFAULT_TIMEOUT; /* has no effect */
  327. case NCP_LOCK_CLEAR:
  328. break;
  329. default:
  330. return -EINVAL;
  331. }
  332. /* locking needs both read and write access */
  333. if ((result = ncp_make_open(inode, O_RDWR)) != 0)
  334. {
  335. return result;
  336. }
  337. result = -EIO;
  338. if (!ncp_conn_valid(server))
  339. goto outrel;
  340. result = -EISDIR;
  341. if (!S_ISREG(inode->i_mode))
  342. goto outrel;
  343. if (rqdata.cmd == NCP_LOCK_CLEAR)
  344. {
  345. result = ncp_ClearPhysicalRecord(NCP_SERVER(inode),
  346. NCP_FINFO(inode)->file_handle, 
  347. rqdata.offset,
  348. rqdata.length);
  349. if (result > 0) result = 0; /* no such lock */
  350. }
  351. else
  352. {
  353. int lockcmd;
  355. switch (rqdata.cmd)
  356. {
  357. case NCP_LOCK_EX:  lockcmd=1; break;
  358. case NCP_LOCK_SH:  lockcmd=3; break;
  359. default:    lockcmd=0; break;
  360. }
  361. result = ncp_LogPhysicalRecord(NCP_SERVER(inode),
  362. NCP_FINFO(inode)->file_handle,
  363. lockcmd,
  364. rqdata.offset,
  365. rqdata.length,
  366. rqdata.timeout);
  367. if (result > 0) result = -EAGAIN;
  368. }
  369. outrel:
  370. ncp_inode_close(inode);
  371. return result;
  372. }
  373. #endif /* CONFIG_NCPFS_IOCTL_LOCKING */
  375. case NCP_IOC_GETOBJECTNAME:
  376. if (current->uid != server->m.mounted_uid) {
  377. return -EACCES;
  378. }
  379. {
  380. struct ncp_objectname_ioctl user;
  381. size_t outl;
  383. if (copy_from_user(&user, 
  384.    (struct ncp_objectname_ioctl*)arg,
  385.    sizeof(user))) return -EFAULT;
  386. user.auth_type = server->auth.auth_type;
  387. outl = user.object_name_len;
  388. user.object_name_len = server->auth.object_name_len;
  389. if (outl > user.object_name_len)
  390. outl = user.object_name_len;
  391. if (outl) {
  392. if (copy_to_user(user.object_name,
  393.  server->auth.object_name,
  394.  outl)) return -EFAULT;
  395. }
  396. if (copy_to_user((struct ncp_objectname_ioctl*)arg,
  397.  &user,
  398.  sizeof(user))) return -EFAULT;
  399. return 0;
  400. }
  401. case NCP_IOC_SETOBJECTNAME:
  402. if (current->uid != server->m.mounted_uid) {
  403. return -EACCES;
  404. }
  405. {
  406. struct ncp_objectname_ioctl user;
  407. void* newname;
  408. void* oldname;
  409. size_t oldnamelen;
  410. void* oldprivate;
  411. size_t oldprivatelen;
  413. if (copy_from_user(&user, 
  414.    (struct ncp_objectname_ioctl*)arg,
  415.    sizeof(user))) return -EFAULT;
  416. if (user.object_name_len > NCP_OBJECT_NAME_MAX_LEN)
  417. return -ENOMEM;
  418. if (user.object_name_len) {
  419. newname = ncp_kmalloc(user.object_name_len, GFP_USER);
  420. if (!newname) return -ENOMEM;
  421. if (copy_from_user(newname, user.object_name, sizeof(user))) {
  422. ncp_kfree_s(newname, user.object_name_len);
  423. return -EFAULT;
  424. }
  425. } else {
  426. newname = NULL;
  427. }
  428. /* enter critical section */
  429. /* maybe that kfree can sleep so do that this way */
  430. /* it is at least more SMP friendly (in future...) */
  431. oldname = server->auth.object_name;
  432. oldnamelen = server->auth.object_name_len;
  433. oldprivate = server->priv.data;
  434. oldprivatelen = server->priv.len;
  435. server->auth.auth_type = user.auth_type;
  436. server->auth.object_name_len = user.object_name_len;
  437. server->auth.object_name = user.object_name;
  438. server->priv.len = 0;
  439. server->priv.data = NULL;
  440. /* leave critical section */
  441. if (oldprivate) ncp_kfree_s(oldprivate, oldprivatelen);
  442. if (oldname) ncp_kfree_s(oldname, oldnamelen);
  443. return 0;
  444. }
  445. case NCP_IOC_GETPRIVATEDATA:
  446. if (current->uid != server->m.mounted_uid) {
  447. return -EACCES;
  448. }
  449. {
  450. struct ncp_privatedata_ioctl user;
  451. size_t outl;
  453. if (copy_from_user(&user, 
  454.    (struct ncp_privatedata_ioctl*)arg,
  455.    sizeof(user))) return -EFAULT;
  456. outl = user.len;
  457. user.len = server->priv.len;
  458. if (outl > user.len) outl = user.len;
  459. if (outl) {
  460. if (copy_to_user(user.data,
  461.  server->priv.data,
  462.  outl)) return -EFAULT;
  463. }
  464. if (copy_to_user((struct ncp_privatedata_ioctl*)arg,
  465.  &user,
  466.  sizeof(user))) return -EFAULT;
  467. return 0;
  468. }
  469. case NCP_IOC_SETPRIVATEDATA:
  470. if (current->uid != server->m.mounted_uid) {
  471. return -EACCES;
  472. }
  473. {
  474. struct ncp_privatedata_ioctl user;
  475. void* new;
  476. void* old;
  477. size_t oldlen;
  479. if (copy_from_user(&user, 
  480.    (struct ncp_privatedata_ioctl*)arg,
  481.    sizeof(user))) return -EFAULT;
  482. if (user.len > NCP_PRIVATE_DATA_MAX_LEN)
  483. return -ENOMEM;
  484. if (user.len) {
  485. new = ncp_kmalloc(user.len, GFP_USER);
  486. if (!new) return -ENOMEM;
  487. if (copy_from_user(new, user.data, user.len)) {
  488. ncp_kfree_s(new, user.len);
  489. return -EFAULT;
  490. }
  491. } else {
  492. new = NULL;
  493. }
  494. /* enter critical section */
  495. old = server->priv.data;
  496. oldlen = server->priv.len;
  497. server->priv.len = user.len;
  498. server->priv.data = new;
  499. /* leave critical section */
  500. if (old) ncp_kfree_s(old, oldlen);
  501. return 0;
  502. }
  504. #ifdef CONFIG_NCPFS_NLS
  505. /* Here we are select the iocharset and the codepage for NLS.
  506.  * Thanks Petr Vandrovec for idea and many hints.
  507.  */
  508. case NCP_IOC_SETCHARSETS:
  509. if (!capable(CAP_SYS_ADMIN))
  510. return -EACCES;
  511. if (server->root_setuped)
  512. return -EBUSY;
  514. {
  515. struct ncp_nls_ioctl user;
  516. struct nls_table *codepage;
  517. struct nls_table *iocharset;
  518. struct nls_table *oldset_io;
  519. struct nls_table *oldset_cp;
  521. if (copy_from_user(&user, (struct ncp_nls_ioctl*)arg,
  522. sizeof(user)))
  523. return -EFAULT;
  525. codepage = NULL;
  526. user.codepage[NCP_IOCSNAME_LEN] = 0;
  527. if (!user.codepage[0] ||
  528. !strcmp(user.codepage, "default"))
  529. codepage = load_nls_default();
  530. else {
  531. codepage = load_nls(user.codepage);
  532. if (!codepage) {
  533. return -EBADRQC;
  534. }
  535. }
  537. iocharset = NULL;
  538. user.iocharset[NCP_IOCSNAME_LEN] = 0;
  539. if (!user.iocharset[0] ||
  540. !strcmp(user.iocharset, "default")) {
  541. iocharset = load_nls_default();
  542. NCP_CLR_FLAG(server, NCP_FLAG_UTF8);
  543. } else {
  544. if (!strcmp(user.iocharset, "utf8")) {
  545. iocharset = load_nls_default();
  546. NCP_SET_FLAG(server, NCP_FLAG_UTF8);
  547. } else {
  548. iocharset = load_nls(user.iocharset);
  549. if (!iocharset) {
  550. unload_nls(codepage);
  551. return -EBADRQC;
  552. }
  553. NCP_CLR_FLAG(server, NCP_FLAG_UTF8);
  554. }
  555. }
  557. oldset_cp = server->nls_vol;
  558. server->nls_vol = codepage;
  559. oldset_io = server->nls_io;
  560. server->nls_io = iocharset;
  562. if (oldset_cp)
  563. unload_nls(oldset_cp);
  564. if (oldset_io)
  565. unload_nls(oldset_io);
  567. return 0;
  568. }
  570. case NCP_IOC_GETCHARSETS: /* not tested */
  571. {
  572. struct ncp_nls_ioctl user;
  573. int len;
  575. memset(&user, 0, sizeof(user));
  576. if (server->nls_vol && server->nls_vol->charset) {
  577. len = strlen(server->nls_vol->charset);
  578. if (len > NCP_IOCSNAME_LEN)
  579. len = NCP_IOCSNAME_LEN;
  580. strncpy(user.codepage,
  581. server->nls_vol->charset, len);
  582. user.codepage[len] = 0;
  583. }
  585. if (NCP_IS_FLAG(server, NCP_FLAG_UTF8))
  586. strcpy(user.iocharset, "utf8");
  587. else
  588. if (server->nls_io && server->nls_io->charset) {
  589. len = strlen(server->nls_io->charset);
  590. if (len > NCP_IOCSNAME_LEN)
  591. len = NCP_IOCSNAME_LEN;
  592. strncpy(user.iocharset,
  593. server->nls_io->charset, len);
  594. user.iocharset[len] = 0;
  595. }
  597. if (copy_to_user((struct ncp_nls_ioctl*)arg, &user,
  598. sizeof(user)))
  599. return -EFAULT;
  601. return 0;
  602. }
  603. #endif /* CONFIG_NCPFS_NLS */
  604. case NCP_IOC_SETDENTRYTTL:
  605. if ((permission(inode, MAY_WRITE) != 0) &&
  606.  (current->uid != server->m.mounted_uid))
  607. return -EACCES;
  608. {
  609. u_int32_t user;
  611. if (copy_from_user(&user, (u_int32_t*)arg, sizeof(user)))
  612. return -EFAULT;
  613. /* 20 secs at most... */
  614. if (user > 20000)
  615. return -EINVAL;
  616. user = (user * HZ) / 1000;
  617. server->dentry_ttl = user;
  618. return 0;
  619. }
  621. case NCP_IOC_GETDENTRYTTL:
  622. {
  623. u_int32_t user = (server->dentry_ttl * 1000) / HZ;
  624. if (copy_to_user((u_int32_t*)arg, &user, sizeof(user)))
  625. return -EFAULT;
  626. return 0;
  627. }
  629. }
  630. /* #ifdef CONFIG_UID16 */
  631. /* NCP_IOC_GETMOUNTUID may be same as NCP_IOC_GETMOUNTUID2,
  632.            so we have this out of switch */
  633. if (cmd == NCP_IOC_GETMOUNTUID) {
  634. if ((permission(inode, MAY_READ) != 0)
  635.     && (current->uid != server->m.mounted_uid)) {
  636. return -EACCES;
  637. }
  638. if (put_user(NEW_TO_OLD_UID(server->m.mounted_uid), (__kernel_uid_t *) arg))
  639. return -EFAULT;
  640. return 0;
  641. }
  642. /* #endif */
  643. return -EINVAL;
  644. }