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

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

Linux/Unix编程

开发平台：

Unix_Linux

svc.c：源码内容
  1. /* net/atm/svc.c - ATM SVC sockets */
  3. /* Written 1995-2000 by Werner Almesberger, EPFL LRC/ICA */
  6. #include <linux/string.h>
  7. #include <linux/net.h> /* struct socket, struct net_proto,
  8.    struct proto_ops */
  9. #include <linux/errno.h> /* error codes */
  10. #include <linux/kernel.h> /* printk */
  11. #include <linux/skbuff.h>
  12. #include <linux/wait.h>
  13. #include <linux/sched.h> /* jiffies and HZ */
  14. #include <linux/fcntl.h> /* O_NONBLOCK */
  15. #include <linux/init.h>
  16. #include <linux/atm.h> /* ATM stuff */
  17. #include <linux/atmsap.h>
  18. #include <linux/atmsvc.h>
  19. #include <linux/atmdev.h>
  20. #include <linux/bitops.h>
  21. #include <net/sock.h> /* for sock_no_* */
  22. #include <asm/uaccess.h>
  24. #include "resources.h"
  25. #include "common.h" /* common for PVCs and SVCs */
  26. #include "signaling.h"
  27. #include "addr.h"
  30. #if 0
  31. #define DPRINTK(format,args...) printk(KERN_DEBUG format,##args)
  32. #else
  33. #define DPRINTK(format,args...)
  34. #endif
  37. static int svc_create(struct socket *sock,int protocol);
  40. /*
  41.  * Note: since all this is still nicely synchronized with the signaling demon,
  42.  *       there's no need to protect sleep loops with clis. If signaling is
  43.  *       moved into the kernel, that would change.
  44.  */
  47. void svc_callback(struct atm_vcc *vcc)
  48. {
  49. wake_up(&vcc->sleep);
  50. }
  55. static int svc_shutdown(struct socket *sock,int how)
  56. {
  57. return 0;
  58. }
  61. static void svc_disconnect(struct atm_vcc *vcc)
  62. {
  63. DECLARE_WAITQUEUE(wait,current);
  64. struct sk_buff *skb;
  66. DPRINTK("svc_disconnect %pn",vcc);
  67. if (test_bit(ATM_VF_REGIS,&vcc->flags)) {
  68. sigd_enq(vcc,as_close,NULL,NULL,NULL);
  69. add_wait_queue(&vcc->sleep,&wait);
  70. while (!test_bit(ATM_VF_RELEASED,&vcc->flags) && sigd) {
  71. set_current_state(TASK_UNINTERRUPTIBLE);
  72. schedule();
  73. }
  74. remove_wait_queue(&vcc->sleep,&wait);
  75. }
  76. /* beware - socket is still in use by atmsigd until the last
  77.    as_indicate has been answered */
  78. while ((skb = skb_dequeue(&vcc->listenq))) {
  79. DPRINTK("LISTEN RELn");
  80. sigd_enq2(NULL,as_reject,vcc,NULL,NULL,&vcc->qos,0);
  81. dev_kfree_skb(skb);
  82. }
  83. clear_bit(ATM_VF_REGIS,&vcc->flags);
  84. clear_bit(ATM_VF_RELEASED,&vcc->flags);
  85. clear_bit(ATM_VF_CLOSE,&vcc->flags);
  86. /* ... may retry later */
  87. }
  90. static int svc_release(struct socket *sock)
  91. {
  92. struct atm_vcc *vcc;
  94. if (!sock->sk) return 0;
  95. vcc = ATM_SD(sock);
  96. DPRINTK("svc_release %pn",vcc);
  97. clear_bit(ATM_VF_READY,&vcc->flags);
  98. atm_release_vcc_sk(sock->sk,0);
  99. svc_disconnect(vcc);
  100.     /* VCC pointer is used as a reference, so we must not free it
  101.        (thereby subjecting it to re-use) before all pending connections
  102.         are closed */
  103. free_atm_vcc_sk(sock->sk);
  104. return 0;
  105. }
  108. static int svc_bind(struct socket *sock,struct sockaddr *sockaddr,
  109.     int sockaddr_len)
  110. {
  111. DECLARE_WAITQUEUE(wait,current);
  112. struct sockaddr_atmsvc *addr;
  113. struct atm_vcc *vcc;
  115. if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) return -EINVAL;
  116. if (sock->state == SS_CONNECTED) return -EISCONN;
  117. if (sock->state != SS_UNCONNECTED) return -EINVAL;
  118. vcc = ATM_SD(sock);
  119. if (test_bit(ATM_VF_SESSION,&vcc->flags)) return -EINVAL;
  120. addr = (struct sockaddr_atmsvc *) sockaddr;
  121. if (addr->sas_family != AF_ATMSVC) return -EAFNOSUPPORT;
  122. clear_bit(ATM_VF_BOUND,&vcc->flags);
  123.     /* failing rebind will kill old binding */
  124. /* @@@ check memory (de)allocation on rebind */
  125. if (!test_bit(ATM_VF_HASQOS,&vcc->flags)) return -EBADFD;
  126. vcc->local = *addr;
  127. vcc->reply = WAITING;
  128. sigd_enq(vcc,as_bind,NULL,NULL,&vcc->local);
  129. add_wait_queue(&vcc->sleep,&wait);
  130. while (vcc->reply == WAITING && sigd) {
  131. set_current_state(TASK_UNINTERRUPTIBLE);
  132. schedule();
  133. }
  134. remove_wait_queue(&vcc->sleep,&wait);
  135. clear_bit(ATM_VF_REGIS,&vcc->flags); /* doesn't count */
  136. if (!sigd) return -EUNATCH;
  137.         if (!vcc->reply) set_bit(ATM_VF_BOUND,&vcc->flags);
  138. return vcc->reply;
  139. }
  142. static int svc_connect(struct socket *sock,struct sockaddr *sockaddr,
  143.     int sockaddr_len,int flags)
  144. {
  145. DECLARE_WAITQUEUE(wait,current);
  146. struct sockaddr_atmsvc *addr;
  147. struct atm_vcc *vcc = ATM_SD(sock);
  148. int error;
  150. DPRINTK("svc_connect %pn",vcc);
  151. if (sockaddr_len != sizeof(struct sockaddr_atmsvc)) return -EINVAL;
  152. if (sock->state == SS_CONNECTED) return -EISCONN;
  153. if (sock->state == SS_CONNECTING) {
  154. if (vcc->reply == WAITING) return -EALREADY;
  155. sock->state = SS_UNCONNECTED;
  156. if (vcc->reply) return vcc->reply;
  157. }
  158. else {
  159. int error;
  161. if (sock->state != SS_UNCONNECTED) return -EINVAL;
  162. if (test_bit(ATM_VF_SESSION,&vcc->flags)) return -EINVAL;
  163. addr = (struct sockaddr_atmsvc *) sockaddr;
  164. if (addr->sas_family != AF_ATMSVC) return -EAFNOSUPPORT;
  165. if (!test_bit(ATM_VF_HASQOS,&vcc->flags)) return -EBADFD;
  166. if (vcc->qos.txtp.traffic_class == ATM_ANYCLASS ||
  167.     vcc->qos.rxtp.traffic_class == ATM_ANYCLASS)
  168. return -EINVAL;
  169. if (!vcc->qos.txtp.traffic_class &&
  170.     !vcc->qos.rxtp.traffic_class) return -EINVAL;
  171. vcc->remote = *addr;
  172. vcc->reply = WAITING;
  173. sigd_enq(vcc,as_connect,NULL,NULL,&vcc->remote);
  174. if (flags & O_NONBLOCK) {
  175. sock->state = SS_CONNECTING;
  176. return -EINPROGRESS;
  177. }
  178. add_wait_queue(&vcc->sleep,&wait);
  179. error = 0;
  180. while (vcc->reply == WAITING && sigd) {
  181. set_current_state(TASK_INTERRUPTIBLE);
  182. schedule();
  183. if (!signal_pending(current)) continue;
  184. DPRINTK("*ABORT*n");
  185. /*
  186.  * This is tricky:
  187.  *   Kernel ---close--> Demon
  188.  *   Kernel <--close--- Demon
  189.          * or
  190.  *   Kernel ---close--> Demon
  191.  *   Kernel <--error--- Demon
  192.  * or
  193.  *   Kernel ---close--> Demon
  194.  *   Kernel <--okay---- Demon
  195.  *   Kernel <--close--- Demon
  196.  */
  197. sigd_enq(vcc,as_close,NULL,NULL,NULL);
  198. while (vcc->reply == WAITING && sigd) {
  199. set_current_state(TASK_UNINTERRUPTIBLE);
  200. schedule();
  201. }
  202. if (!vcc->reply)
  203. while (!test_bit(ATM_VF_RELEASED,&vcc->flags)
  204.     && sigd) {
  205. set_current_state(TASK_UNINTERRUPTIBLE);
  206. schedule();
  207. }
  208. clear_bit(ATM_VF_REGIS,&vcc->flags);
  209. clear_bit(ATM_VF_RELEASED,&vcc->flags);
  210. clear_bit(ATM_VF_CLOSE,&vcc->flags);
  211.     /* we're gone now but may connect later */
  212. error = -EINTR;
  213. break;
  214. }
  215. remove_wait_queue(&vcc->sleep,&wait);
  216. if (error) return error;
  217. if (!sigd) return -EUNATCH;
  218. if (vcc->reply) return vcc->reply;
  219. }
  220. /*
  221.  * Not supported yet
  222.  *
  223.  * #ifndef CONFIG_SINGLE_SIGITF
  224.  */
  225. vcc->qos.txtp.max_pcr = SELECT_TOP_PCR(vcc->qos.txtp);
  226. vcc->qos.txtp.pcr = 0;
  227. vcc->qos.txtp.min_pcr = 0;
  228. /*
  229.  * #endif
  230.  */
  231. if (!(error = atm_connect(sock,vcc->itf,vcc->vpi,vcc->vci)))
  232. sock->state = SS_CONNECTED;
  233. else (void) svc_disconnect(vcc);
  234. return error;
  235. }
  238. static int svc_listen(struct socket *sock,int backlog)
  239. {
  240. DECLARE_WAITQUEUE(wait,current);
  241. struct atm_vcc *vcc = ATM_SD(sock);
  243. DPRINTK("svc_listen %pn",vcc);
  244. /* let server handle listen on unbound sockets */
  245. if (test_bit(ATM_VF_SESSION,&vcc->flags)) return -EINVAL;
  246. vcc->reply = WAITING;
  247. sigd_enq(vcc,as_listen,NULL,NULL,&vcc->local);
  248. add_wait_queue(&vcc->sleep,&wait);
  249. while (vcc->reply == WAITING && sigd) {
  250. set_current_state(TASK_UNINTERRUPTIBLE);
  251. schedule();
  252. }
  253. remove_wait_queue(&vcc->sleep,&wait);
  254. if (!sigd) return -EUNATCH;
  255. set_bit(ATM_VF_LISTEN,&vcc->flags);
  256. vcc->backlog_quota = backlog > 0 ? backlog : ATM_BACKLOG_DEFAULT;
  257. return vcc->reply;
  258. }
  261. static int svc_accept(struct socket *sock,struct socket *newsock,int flags)
  262. {
  263. struct sk_buff *skb;
  264. struct atmsvc_msg *msg;
  265. struct atm_vcc *old_vcc = ATM_SD(sock);
  266. struct atm_vcc *new_vcc;
  267. int error;
  269. error = svc_create(newsock,0);
  270. if (error)
  271. return error;
  273. new_vcc = ATM_SD(newsock);
  275. DPRINTK("svc_accept %p -> %pn",old_vcc,new_vcc);
  276. while (1) {
  277. DECLARE_WAITQUEUE(wait,current);
  279. add_wait_queue(&old_vcc->sleep,&wait);
  280. while (!(skb = skb_dequeue(&old_vcc->listenq)) && sigd) {
  281. if (test_bit(ATM_VF_RELEASED,&old_vcc->flags)) break;
  282. if (test_bit(ATM_VF_CLOSE,&old_vcc->flags)) {
  283. error = old_vcc->reply;
  284. break;
  285. }
  286. if (flags & O_NONBLOCK) {
  287. error = -EAGAIN;
  288. break;
  289. }
  290. set_current_state(TASK_INTERRUPTIBLE);
  291. schedule();
  292. if (signal_pending(current)) {
  293. error = -ERESTARTSYS;
  294. break;
  295. }
  296. }
  297. remove_wait_queue(&old_vcc->sleep,&wait);
  298. if (error) return error;
  299. if (!skb) return -EUNATCH;
  300. msg = (struct atmsvc_msg *) skb->data;
  301. new_vcc->qos = msg->qos;
  302. set_bit(ATM_VF_HASQOS,&new_vcc->flags);
  303. new_vcc->remote = msg->svc;
  304. new_vcc->local = msg->local;
  305. new_vcc->sap = msg->sap;
  306. error = atm_connect(newsock,msg->pvc.sap_addr.itf,
  307.     msg->pvc.sap_addr.vpi,msg->pvc.sap_addr.vci);
  308. dev_kfree_skb(skb);
  309. old_vcc->backlog_quota++;
  310. if (error) {
  311. sigd_enq2(NULL,as_reject,old_vcc,NULL,NULL,
  312.     &old_vcc->qos,error);
  313. return error == -EAGAIN ? -EBUSY : error;
  314. }
  315. /* wait should be short, so we ignore the non-blocking flag */
  316. new_vcc->reply = WAITING;
  317. sigd_enq(new_vcc,as_accept,old_vcc,NULL,NULL);
  318. add_wait_queue(&new_vcc->sleep,&wait);
  319. while (new_vcc->reply == WAITING && sigd) {
  320. set_current_state(TASK_UNINTERRUPTIBLE);
  321. schedule();
  322. }
  323. remove_wait_queue(&new_vcc->sleep,&wait);
  324. if (!sigd) return -EUNATCH;
  325. if (!new_vcc->reply) break;
  326. if (new_vcc->reply != -ERESTARTSYS) return new_vcc->reply;
  327. }
  328. newsock->state = SS_CONNECTED;
  329. return 0;
  330. }
  333. static int svc_getname(struct socket *sock,struct sockaddr *sockaddr,
  334.     int *sockaddr_len,int peer)
  335. {
  336. struct sockaddr_atmsvc *addr;
  338. *sockaddr_len = sizeof(struct sockaddr_atmsvc);
  339. addr = (struct sockaddr_atmsvc *) sockaddr;
  340. memcpy(addr,peer ? &ATM_SD(sock)->remote : &ATM_SD(sock)->local,
  341.     sizeof(struct sockaddr_atmsvc));
  342. return 0;
  343. }
  346. int svc_change_qos(struct atm_vcc *vcc,struct atm_qos *qos)
  347. {
  348. DECLARE_WAITQUEUE(wait,current);
  350. vcc->reply = WAITING;
  351. sigd_enq2(vcc,as_modify,NULL,NULL,&vcc->local,qos,0);
  352. add_wait_queue(&vcc->sleep,&wait);
  353. while (vcc->reply == WAITING && !test_bit(ATM_VF_RELEASED,&vcc->flags)
  354.     && sigd) {
  355. set_current_state(TASK_UNINTERRUPTIBLE);
  356. schedule();
  357. }
  358. remove_wait_queue(&vcc->sleep,&wait);
  359. if (!sigd) return -EUNATCH;
  360. return vcc->reply;
  361. }
  364. static int svc_setsockopt(struct socket *sock,int level,int optname,
  365.     char *optval,int optlen)
  366. {
  367. struct atm_vcc *vcc;
  369. if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP ||
  370.     optlen != sizeof(struct atm_sap))
  371. return atm_setsockopt(sock,level,optname,optval,optlen);
  372. vcc = ATM_SD(sock);
  373. if (copy_from_user(&vcc->sap,optval,optlen)) return -EFAULT;
  374. set_bit(ATM_VF_HASSAP,&vcc->flags);
  375. return 0;
  376. }
  379. static int svc_getsockopt(struct socket *sock,int level,int optname,
  380.     char *optval,int *optlen)
  381. {
  382. int len;
  384. if (!__SO_LEVEL_MATCH(optname, level) || optname != SO_ATMSAP)
  385. return atm_getsockopt(sock,level,optname,optval,optlen);
  386. if (get_user(len,optlen)) return -EFAULT;
  387. if (len != sizeof(struct atm_sap)) return -EINVAL;
  388. return copy_to_user(optval,&ATM_SD(sock)->sap,sizeof(struct atm_sap)) ?
  389.     -EFAULT : 0;
  390. }
  393. static struct proto_ops SOCKOPS_WRAPPED(svc_proto_ops) = {
  394. family: PF_ATMSVC,
  396. release: svc_release,
  397. bind: svc_bind,
  398. connect: svc_connect,
  399. socketpair: sock_no_socketpair,
  400. accept: svc_accept,
  401. getname: svc_getname,
  402. poll: atm_poll,
  403. ioctl: atm_ioctl,
  404. listen: svc_listen,
  405. shutdown: svc_shutdown,
  406. setsockopt: svc_setsockopt,
  407. getsockopt: svc_getsockopt,
  408. sendmsg: atm_sendmsg,
  409. recvmsg: atm_recvmsg,
  410. mmap: sock_no_mmap,
  411. sendpage: sock_no_sendpage,
  412. };
  415. #include <linux/smp_lock.h>
  416. SOCKOPS_WRAP(svc_proto, PF_ATMSVC);
  418. static int svc_create(struct socket *sock,int protocol)
  419. {
  420. int error;
  422. sock->ops = &svc_proto_ops;
  423. error = atm_create(sock,protocol,AF_ATMSVC);
  424. if (error) return error;
  425. ATM_SD(sock)->callback = svc_callback;
  426. ATM_SD(sock)->local.sas_family = AF_ATMSVC;
  427. ATM_SD(sock)->remote.sas_family = AF_ATMSVC;
  428. return 0;
  429. }
  432. static struct net_proto_family svc_family_ops = {
  433. PF_ATMSVC,
  434. svc_create,
  435. 0, /* no authentication */
  436. 0, /* no encryption */
  437. 0 /* no encrypt_net */
  438. };
  441. /*
  442.  * Initialize the ATM SVC protocol family
  443.  */
  445. static int __init atmsvc_init(void)
  446. {
  447. if (sock_register(&svc_family_ops) < 0) {
  448. printk(KERN_ERR "ATMSVC: can't register");
  449. return -1;
  450. }
  451. return 0;
  452. }
  454. module_init(atmsvc_init);