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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
sock.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：16k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

sock.c：源码内容
  1. /*
  2.  *  linux/fs/ncpfs/sock.c
  3.  *
  4.  *  Copyright (C) 1992, 1993  Rick Sladkey
  5.  *
  6.  *  Modified 1995, 1996 by Volker Lendecke to be usable for ncp
  7.  *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
  8.  *
  9.  */
  11. #include <linux/config.h>
  13. #include <linux/sched.h>
  14. #include <linux/errno.h>
  15. #include <linux/socket.h>
  16. #include <linux/fcntl.h>
  17. #include <linux/stat.h>
  18. #include <asm/uaccess.h>
  19. #include <linux/in.h>
  20. #include <linux/net.h>
  21. #include <linux/mm.h>
  22. #include <linux/netdevice.h>
  23. #include <linux/signal.h>
  24. #include <net/scm.h>
  25. #include <net/sock.h>
  26. #include <linux/ipx.h>
  27. #include <linux/poll.h>
  28. #include <linux/file.h>
  30. #include <linux/ncp_fs.h>
  32. #ifdef CONFIG_NCPFS_PACKET_SIGNING
  33. #include "ncpsign_kernel.h"
  34. #endif
  36. static int _recv(struct socket *sock, unsigned char *ubuf, int size,
  37.  unsigned flags)
  38. {
  39. struct iovec iov;
  40. struct msghdr msg;
  41. struct scm_cookie scm;
  43. memset(&scm, 0, sizeof(scm));
  45. iov.iov_base = ubuf;
  46. iov.iov_len = size;
  48. msg.msg_name = NULL;
  49. msg.msg_namelen = 0;
  50. msg.msg_control = NULL;
  51. msg.msg_iov = &iov;
  52. msg.msg_iovlen = 1;
  53. return sock->ops->recvmsg(sock, &msg, size, flags, &scm);
  54. }
  56. static int _send(struct socket *sock, const void *buff, int len)
  57. {
  58. struct iovec iov;
  59. struct msghdr msg;
  60. struct scm_cookie scm;
  61. int err;
  63. iov.iov_base = (void *) buff;
  64. iov.iov_len = len;
  66. msg.msg_name = NULL;
  67. msg.msg_namelen = 0;
  68. msg.msg_control = NULL;
  69. msg.msg_iov = &iov;
  70. msg.msg_iovlen = 1;
  71. msg.msg_flags = 0;
  73. err = scm_send(sock, &msg, &scm);
  74. if (err < 0) {
  75. return err;
  76. }
  77. err = sock->ops->sendmsg(sock, &msg, len, &scm);
  78. scm_destroy(&scm);
  79. return err;
  80. }
  82. static int do_ncp_rpc_call(struct ncp_server *server, int size,
  83. struct ncp_reply_header* reply_buf, int max_reply_size)
  84. {
  85. struct file *file;
  86. struct socket *sock;
  87. int result;
  88. char *start = server->packet;
  89. poll_table wait_table;
  90. int init_timeout, max_timeout;
  91. int timeout;
  92. int retrans;
  93. int major_timeout_seen;
  94. int acknowledge_seen;
  95. int n;
  97. /* We have to check the result, so store the complete header */
  98. struct ncp_request_header request =
  99. *((struct ncp_request_header *) (server->packet));
  101. struct ncp_reply_header reply;
  103. file = server->ncp_filp;
  104. sock = &file->f_dentry->d_inode->u.socket_i;
  106. init_timeout = server->m.time_out;
  107. max_timeout = NCP_MAX_RPC_TIMEOUT;
  108. retrans = server->m.retry_count;
  109. major_timeout_seen = 0;
  110. acknowledge_seen = 0;
  112. for (n = 0, timeout = init_timeout;; n++, timeout <<= 1) {
  113. /*
  114. DDPRINTK("ncpfs: %08lX:%02X%02X%02X%02X%02X%02X:%04Xn",
  115.  htonl(server->m.serv_addr.sipx_network),
  116.  server->m.serv_addr.sipx_node[0],
  117.  server->m.serv_addr.sipx_node[1],
  118.  server->m.serv_addr.sipx_node[2],
  119.  server->m.serv_addr.sipx_node[3],
  120.  server->m.serv_addr.sipx_node[4],
  121.  server->m.serv_addr.sipx_node[5],
  122.  ntohs(server->m.serv_addr.sipx_port));
  123. */
  124. DDPRINTK("ncpfs: req.typ: %04X, con: %d, "
  125.  "seq: %d",
  126.  request.type,
  127.  (request.conn_high << 8) + request.conn_low,
  128.  request.sequence);
  129. DDPRINTK(" func: %dn",
  130.  request.function);
  132. result = _send(sock, (void *) start, size);
  133. if (result < 0) {
  134. printk(KERN_ERR "ncp_rpc_call: send error = %dn", result);
  135. break;
  136. }
  137.       re_select:
  138. poll_initwait(&wait_table);
  139. /* mb() is not necessary because ->poll() will serialize
  140.    instructions adding the wait_table waitqueues in the
  141.    waitqueue-head before going to calculate the mask-retval. */
  142. __set_current_state(TASK_INTERRUPTIBLE);
  143. if (!(sock->ops->poll(file, sock, &wait_table) & POLLIN)) {
  144. int timed_out;
  145. if (timeout > max_timeout) {
  146. /* JEJB/JSP 2/7/94
  147.  * This is useful to see if the system is
  148.  * hanging */
  149. if (acknowledge_seen == 0) {
  150. printk(KERN_WARNING "NCP max timeoutn");
  151. }
  152. timeout = max_timeout;
  153. }
  154. timed_out = !schedule_timeout(timeout);
  155. poll_freewait(&wait_table);
  156. current->state = TASK_RUNNING;
  157. if (signal_pending(current)) {
  158. result = -ERESTARTSYS;
  159. break;
  160. }
  161. if(wait_table.error) {
  162. result = wait_table.error;
  163. break;
  164. }
  165. if (timed_out) {
  166. if (n < retrans)
  167. continue;
  168. if (server->m.flags & NCP_MOUNT_SOFT) {
  169. printk(KERN_WARNING "NCP server not respondingn");
  170. result = -EIO;
  171. break;
  172. }
  173. n = 0;
  174. timeout = init_timeout;
  175. if (init_timeout < max_timeout)
  176. init_timeout <<= 1;
  177. if (!major_timeout_seen) {
  178. printk(KERN_WARNING "NCP server not respondingn");
  179. }
  180. major_timeout_seen = 1;
  181. continue;
  182. }
  183. } else {
  184. poll_freewait(&wait_table);
  185. }
  186. current->state = TASK_RUNNING;
  188. /* Get the header from the next packet using a peek, so keep it
  189.  * on the recv queue.  If it is wrong, it will be some reply
  190.  * we don't now need, so discard it */
  191. result = _recv(sock, (void *) &reply, sizeof(reply),
  192.        MSG_PEEK | MSG_DONTWAIT);
  193. if (result < 0) {
  194. if (result == -EAGAIN) {
  195. DDPRINTK("ncp_rpc_call: bad select readyn");
  196. goto re_select;
  197. }
  198. if (result == -ECONNREFUSED) {
  199. DPRINTK("ncp_rpc_call: server playing coyn");
  200. goto re_select;
  201. }
  202. if (result != -ERESTARTSYS) {
  203. printk(KERN_ERR "ncp_rpc_call: recv error = %dn",
  204.        -result);
  205. }
  206. break;
  207. }
  208. if ((result == sizeof(reply))
  209.     && (reply.type == NCP_POSITIVE_ACK)) {
  210. /* Throw away the packet */
  211. DPRINTK("ncp_rpc_call: got positive acknowledgen");
  212. _recv(sock, (void *) &reply, sizeof(reply),
  213.       MSG_DONTWAIT);
  214. n = 0;
  215. timeout = max_timeout;
  216. acknowledge_seen = 1;
  217. goto re_select;
  218. }
  219. DDPRINTK("ncpfs: rep.typ: %04X, con: %d, tsk: %d,"
  220.  "seq: %dn",
  221.  reply.type,
  222.  (reply.conn_high << 8) + reply.conn_low,
  223.  reply.task,
  224.  reply.sequence);
  226. if ((result >= sizeof(reply))
  227.     && (reply.type == NCP_REPLY)
  228.     && ((request.type == NCP_ALLOC_SLOT_REQUEST)
  229. || ((reply.sequence == request.sequence)
  230.     && (reply.conn_low == request.conn_low)
  231. /* seem to get wrong task from NW311 && (reply.task      == request.task) */
  232.     && (reply.conn_high == request.conn_high)))) {
  233. if (major_timeout_seen)
  234. printk(KERN_NOTICE "NCP server OKn");
  235. break;
  236. }
  237. /* JEJB/JSP 2/7/94
  238.  * we have xid mismatch, so discard the packet and start
  239.  * again.  What a hack! but I can't call recvfrom with
  240.  * a null buffer yet. */
  241. _recv(sock, (void *) &reply, sizeof(reply), MSG_DONTWAIT);
  243. DPRINTK("ncp_rpc_call: reply mismatchn");
  244. goto re_select;
  245. }
  246. /* 
  247.  * we have the correct reply, so read into the correct place and
  248.  * return it
  249.  */
  250. result = _recv(sock, (void *)reply_buf, max_reply_size, MSG_DONTWAIT);
  251. if (result < 0) {
  252. printk(KERN_WARNING "NCP: notice message: result=%dn", result);
  253. } else if (result < sizeof(struct ncp_reply_header)) {
  254. printk(KERN_ERR "NCP: just caught a too small read memory size..., "
  255.        "email to NET channeln");
  256. printk(KERN_ERR "NCP: result=%dn", result);
  257. result = -EIO;
  258. }
  260. return result;
  261. }
  263. static int do_tcp_rcv(struct ncp_server *server, void *buffer, size_t len) {
  264. poll_table wait_table;
  265. struct file *file;
  266. struct socket *sock;
  267. int init_timeout;
  268. size_t dataread;
  269. int result = 0;
  271. file = server->ncp_filp;
  272. sock = &file->f_dentry->d_inode->u.socket_i;
  274. dataread = 0;
  276. init_timeout = server->m.time_out * 20;
  278. /* hard-mounted volumes have no timeout, except connection close... */
  279. if (!(server->m.flags & NCP_MOUNT_SOFT))
  280. init_timeout = 0x7FFF0000;
  282. while (len) {
  283. poll_initwait(&wait_table);
  284. /* mb() is not necessary because ->poll() will serialize
  285.    instructions adding the wait_table waitqueues in the
  286.    waitqueue-head before going to calculate the mask-retval. */
  287. __set_current_state(TASK_INTERRUPTIBLE);
  288. if (!(sock->ops->poll(file, sock, &wait_table) & POLLIN)) {
  289. init_timeout = schedule_timeout(init_timeout);
  290. poll_freewait(&wait_table);
  291. current->state = TASK_RUNNING;
  292. if (signal_pending(current)) {
  293. return -ERESTARTSYS;
  294. }
  295. if (!init_timeout) {
  296. return -EIO;
  297. }
  298. if(wait_table.error) {
  299. return wait_table.error;
  300. }
  301. } else {
  302. poll_freewait(&wait_table);
  303. }
  304. current->state = TASK_RUNNING;
  306. result = _recv(sock, buffer, len, MSG_DONTWAIT);
  307. if (result < 0) {
  308. if (result == -EAGAIN) {
  309. DDPRINTK("ncpfs: tcp: bad select readyn");
  310. continue;
  311. }
  312. return result;
  313. }
  314. if (result == 0) {
  315. printk(KERN_ERR "ncpfs: tcp: EOF on socketn");
  316. return -EIO;
  317. }
  318. if (result > len) {
  319. printk(KERN_ERR "ncpfs: tcp: bug in recvmsgn");
  320. return -EIO;
  321. }
  322. dataread += result;
  323. buffer += result;
  324. len -= result;
  325. }
  326. return 0;
  327. }
  329. #define NCP_TCP_XMIT_MAGIC (0x446D6454)
  330. #define NCP_TCP_XMIT_VERSION (1)
  331. #define NCP_TCP_RCVD_MAGIC (0x744E6350)
  333. static int do_ncp_tcp_rpc_call(struct ncp_server *server, int size,
  334. struct ncp_reply_header* reply_buf, int max_reply_size)
  335. {
  336. struct file *file;
  337. struct socket *sock;
  338. int result;
  339. struct iovec iov[2];
  340. struct msghdr msg;
  341. struct scm_cookie scm;
  342. __u32 ncptcp_rcvd_hdr[2];
  343. __u32 ncptcp_xmit_hdr[4];
  344. int   datalen;
  346. /* We have to check the result, so store the complete header */
  347. struct ncp_request_header request =
  348. *((struct ncp_request_header *) (server->packet));
  350. file = server->ncp_filp;
  351. sock = &file->f_dentry->d_inode->u.socket_i;
  353. ncptcp_xmit_hdr[0] = htonl(NCP_TCP_XMIT_MAGIC);
  354. ncptcp_xmit_hdr[1] = htonl(size + 16);
  355. ncptcp_xmit_hdr[2] = htonl(NCP_TCP_XMIT_VERSION);
  356. ncptcp_xmit_hdr[3] = htonl(max_reply_size + 8);
  358. DDPRINTK("ncpfs: req.typ: %04X, con: %d, "
  359.  "seq: %d",
  360.  request.type,
  361.  (request.conn_high << 8) + request.conn_low,
  362.  request.sequence);
  363. DDPRINTK(" func: %dn",
  364.  request.function);
  366. iov[1].iov_base = (void *) server->packet;
  367. iov[1].iov_len = size;
  368. iov[0].iov_base = ncptcp_xmit_hdr;
  369. iov[0].iov_len = 16;
  370. msg.msg_name = NULL;
  371. msg.msg_namelen = 0;
  372. msg.msg_control = NULL;
  373. msg.msg_iov = iov;
  374. msg.msg_iovlen = 2;
  375. msg.msg_flags = MSG_NOSIGNAL;
  377. result = scm_send(sock, &msg, &scm);
  378. if (result < 0) {
  379. return result;
  380. }
  381. result = sock->ops->sendmsg(sock, &msg, size + 16, &scm);
  382. scm_destroy(&scm);
  383. if (result < 0) {
  384. printk(KERN_ERR "ncpfs: tcp: Send failed: %dn", result);
  385. return result;
  386. }
  387. rstrcv:
  388. result = do_tcp_rcv(server, ncptcp_rcvd_hdr, 8);
  389. if (result)
  390. return result;
  391. if (ncptcp_rcvd_hdr[0] != htonl(NCP_TCP_RCVD_MAGIC)) {
  392. printk(KERN_ERR "ncpfs: tcp: Unexpected reply type %08Xn", ntohl(ncptcp_rcvd_hdr[0]));
  393. return -EIO;
  394. }
  395. datalen = ntohl(ncptcp_rcvd_hdr[1]);
  396. if (datalen < 8 + sizeof(*reply_buf) || datalen > max_reply_size + 8) {
  397. printk(KERN_ERR "ncpfs: tcp: Unexpected reply len %dn", datalen);
  398. return -EIO;
  399. }
  400. datalen -= 8;
  401. result = do_tcp_rcv(server, reply_buf, datalen);
  402. if (result)
  403. return result;
  404. if (reply_buf->type != NCP_REPLY) {
  405. DDPRINTK("ncpfs: tcp: Unexpected NCP type %02Xn", reply_buf->type);
  406. goto rstrcv;
  407. }
  408. if (request.type == NCP_ALLOC_SLOT_REQUEST)
  409. return datalen;
  410. if (reply_buf->sequence != request.sequence) {
  411. printk(KERN_ERR "ncpfs: tcp: Bad sequence numbern");
  412. return -EIO;
  413. }
  414. if ((reply_buf->conn_low != request.conn_low) ||
  415.     (reply_buf->conn_high != request.conn_high)) {
  416. printk(KERN_ERR "ncpfs: tcp: Connection number mismatchn");
  417. return -EIO;
  418. }
  419. return datalen;
  420. }
  422. /*
  423.  * We need the server to be locked here, so check!
  424.  */
  426. static int ncp_do_request(struct ncp_server *server, int size,
  427. void* reply, int max_reply_size)
  428. {
  429. struct file *file;
  430. struct socket *sock;
  431. int result;
  433. if (server->lock == 0) {
  434. printk(KERN_ERR "ncpfs: Server not locked!n");
  435. return -EIO;
  436. }
  437. if (!ncp_conn_valid(server)) {
  438. return -EIO;
  439. }
  440. #ifdef CONFIG_NCPFS_PACKET_SIGNING
  441. if (server->sign_active)
  442. {
  443. sign_packet(server, &size);
  444. }
  445. #endif /* CONFIG_NCPFS_PACKET_SIGNING */
  446. file = server->ncp_filp;
  447. sock = &file->f_dentry->d_inode->u.socket_i;
  448. /* N.B. this isn't needed ... check socket type? */
  449. if (!sock) {
  450. printk(KERN_ERR "ncp_rpc_call: socki_lookup failedn");
  451. result = -EBADF;
  452. } else {
  453. mm_segment_t fs;
  454. sigset_t old_set;
  455. unsigned long mask, flags;
  457. spin_lock_irqsave(&current->sigmask_lock, flags);
  458. old_set = current->blocked;
  459. if (current->flags & PF_EXITING)
  460. mask = 0;
  461. else
  462. mask = sigmask(SIGKILL);
  463. if (server->m.flags & NCP_MOUNT_INTR) {
  464. /* FIXME: This doesn't seem right at all.  So, like,
  465.    we can't handle SIGINT and get whatever to stop?
  466.    What if we've blocked it ourselves?  What about
  467.    alarms?  Why, in fact, are we mucking with the
  468.    sigmask at all? -- r~ */
  469. if (current->sig->action[SIGINT - 1].sa.sa_handler == SIG_DFL)
  470. mask |= sigmask(SIGINT);
  471. if (current->sig->action[SIGQUIT - 1].sa.sa_handler == SIG_DFL)
  472. mask |= sigmask(SIGQUIT);
  473. }
  474. siginitsetinv(&current->blocked, mask);
  475. recalc_sigpending(current);
  476. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  478. fs = get_fs();
  479. set_fs(get_ds());
  481. if (sock->type == SOCK_STREAM)
  482. result = do_ncp_tcp_rpc_call(server, size, reply, max_reply_size);
  483. else
  484. result = do_ncp_rpc_call(server, size, reply, max_reply_size);
  486. set_fs(fs);
  488. spin_lock_irqsave(&current->sigmask_lock, flags);
  489. current->blocked = old_set;
  490. recalc_sigpending(current);
  491. spin_unlock_irqrestore(&current->sigmask_lock, flags);
  492. }
  494. DDPRINTK("do_ncp_rpc_call returned %dn", result);
  496. if (result < 0) {
  497. /* There was a problem with I/O, so the connections is
  498.  * no longer usable. */
  499. ncp_invalidate_conn(server);
  500. }
  501. return result;
  502. }
  504. /* ncp_do_request assures that at least a complete reply header is
  505.  * received. It assumes that server->current_size contains the ncp
  506.  * request size
  507.  */
  508. int ncp_request2(struct ncp_server *server, int function, 
  509. void* rpl, int size)
  510. {
  511. struct ncp_request_header *h;
  512. struct ncp_reply_header* reply = rpl;
  513. int request_size = server->current_size
  514.  - sizeof(struct ncp_request_header);
  515. int result;
  517. h = (struct ncp_request_header *) (server->packet);
  518. if (server->has_subfunction != 0) {
  519. *(__u16 *) & (h->data[0]) = htons(request_size - 2);
  520. }
  521. h->type = NCP_REQUEST;
  523. server->sequence += 1;
  524. h->sequence = server->sequence;
  525. h->conn_low = (server->connection) & 0xff;
  526. h->conn_high = ((server->connection) & 0xff00) >> 8;
  527. /*
  528.  * The server shouldn't know or care what task is making a
  529.  * request, so we always use the same task number.
  530.  */
  531. h->task = 2; /* (current->pid) & 0xff; */
  532. h->function = function;
  534. result = ncp_do_request(server, request_size + sizeof(*h), reply, size);
  535. if (result < 0) {
  536. DPRINTK("ncp_request_error: %dn", result);
  537. goto out;
  538. }
  539. server->completion = reply->completion_code;
  540. server->conn_status = reply->connection_state;
  541. server->reply_size = result;
  542. server->ncp_reply_size = result - sizeof(struct ncp_reply_header);
  544. result = reply->completion_code;
  546. if (result != 0)
  547. PPRINTK("ncp_request: completion code=%xn", result);
  548. out:
  549. return result;
  550. }
  552. int ncp_connect(struct ncp_server *server)
  553. {
  554. struct ncp_request_header *h;
  555. int result;
  557. h = (struct ncp_request_header *) (server->packet);
  558. h->type = NCP_ALLOC_SLOT_REQUEST;
  560. server->sequence = 0;
  561. h->sequence = server->sequence;
  562. h->conn_low = 0xff;
  563. h->conn_high = 0xff;
  564. h->task = 2; /* see above */
  565. h->function = 0;
  567. result = ncp_do_request(server, sizeof(*h), server->packet, server->packet_size);
  568. if (result < 0)
  569. goto out;
  570. server->sequence = 0;
  571. server->connection = h->conn_low + (h->conn_high * 256);
  572. result = 0;
  573. out:
  574. return result;
  575. }
  577. int ncp_disconnect(struct ncp_server *server)
  578. {
  579. struct ncp_request_header *h;
  581. h = (struct ncp_request_header *) (server->packet);
  582. h->type = NCP_DEALLOC_SLOT_REQUEST;
  584. server->sequence += 1;
  585. h->sequence = server->sequence;
  586. h->conn_low = (server->connection) & 0xff;
  587. h->conn_high = ((server->connection) & 0xff00) >> 8;
  588. h->task = 2; /* see above */
  589. h->function = 0;
  591. return ncp_do_request(server, sizeof(*h), server->packet, server->packet_size);
  592. }
  594. void ncp_lock_server(struct ncp_server *server)
  595. {
  596. down(&server->sem);
  597. if (server->lock)
  598. printk(KERN_WARNING "ncp_lock_server: was locked!n");
  599. server->lock = 1;
  600. }
  602. void ncp_unlock_server(struct ncp_server *server)
  603. {
  604. if (!server->lock) {
  605. printk(KERN_WARNING "ncp_unlock_server: was not locked!n");
  606. return;
  607. }
  608. server->lock = 0;
  609. up(&server->sem);
  610. }