1 /* uipc_socket2.c 6.2 84/01/11 */ 2 3 #include "../h/param.h" 4 #include "../h/systm.h" 5 #include "../h/dir.h" 6 #include "../h/user.h" 7 #include "../h/proc.h" 8 #include "../h/file.h" 9 #include "../h/inode.h" 10 #include "../h/buf.h" 11 #include "../h/mbuf.h" 12 #include "../h/protosw.h" 13 #include "../h/socket.h" 14 #include "../h/socketvar.h" 15 16 /* 17 * Primitive routines for operating on sockets and socket buffers 18 */ 19 20 /* 21 * Procedures to manipulate state flags of socket 22 * and do appropriate wakeups. Normal sequence from the 23 * active (originating) side is that soisconnecting() is 24 * called during processing of connect() call, 25 * resulting in an eventual call to soisconnected() if/when the 26 * connection is established. When the connection is torn down 27 * soisdisconnecting() is called during processing of disconnect() call, 28 * and soisdisconnected() is called when the connection to the peer 29 * is totally severed. The semantics of these routines are such that 30 * connectionless protocols can call soisconnected() and soisdisconnected() 31 * only, bypassing the in-progress calls when setting up a ``connection'' 32 * takes no time. 33 * 34 * From the passive side, a socket is created with 35 * two queues of sockets: so_q0 for connections in progress 36 * and so_q for connections already made and awaiting user acceptance. 37 * As a protocol is preparing incoming connections, it creates a socket 38 * structure queued on so_q0 by calling sonewconn(). When the connection 39 * is established, soisconnected() is called, and transfers the 40 * socket structure to so_q, making it available to accept(). 41 * 42 * If a socket is closed with sockets on either 43 * so_q0 or so_q, these sockets are dropped. 44 * 45 * If higher level protocols are implemented in 46 * the kernel, the wakeups done here will sometimes 47 * cause software-interrupt process scheduling. 48 */ 49 50 soisconnecting(so) 51 register struct socket *so; 52 { 53 54 so->so_state &= ~(SS_ISCONNECTED|SS_ISDISCONNECTING); 55 so->so_state |= SS_ISCONNECTING; 56 wakeup((caddr_t)&so->so_timeo); 57 } 58 59 soisconnected(so) 60 register struct socket *so; 61 { 62 register struct socket *head = so->so_head; 63 64 if (head) { 65 if (soqremque(so, 0) == 0) 66 panic("soisconnected"); 67 soqinsque(head, so, 1); 68 sorwakeup(head); 69 wakeup((caddr_t)&head->so_timeo); 70 } 71 so->so_state &= ~(SS_ISCONNECTING|SS_ISDISCONNECTING); 72 so->so_state |= SS_ISCONNECTED; 73 wakeup((caddr_t)&so->so_timeo); 74 sorwakeup(so); 75 sowwakeup(so); 76 } 77 78 soisdisconnecting(so) 79 register struct socket *so; 80 { 81 82 so->so_state &= ~SS_ISCONNECTING; 83 so->so_state |= (SS_ISDISCONNECTING|SS_CANTRCVMORE|SS_CANTSENDMORE); 84 wakeup((caddr_t)&so->so_timeo); 85 sowwakeup(so); 86 sorwakeup(so); 87 } 88 89 soisdisconnected(so) 90 register struct socket *so; 91 { 92 93 so->so_state &= ~(SS_ISCONNECTING|SS_ISCONNECTED|SS_ISDISCONNECTING); 94 so->so_state |= (SS_CANTRCVMORE|SS_CANTSENDMORE); 95 wakeup((caddr_t)&so->so_timeo); 96 sowwakeup(so); 97 sorwakeup(so); 98 } 99 100 /* 101 * When an attempt at a new connection is noted on a socket 102 * which accepts connections, sonewconn is called. If the 103 * connection is possible (subject to space constraints, etc.) 104 * then we allocate a new structure, propoerly linked into the 105 * data structure of the original socket, and return this. 106 */ 107 struct socket * 108 sonewconn(head) 109 register struct socket *head; 110 { 111 register struct socket *so; 112 register struct mbuf *m; 113 114 if (head->so_qlen + head->so_q0len > 3 * head->so_qlimit / 2) 115 goto bad; 116 m = m_getclr(M_DONTWAIT, MT_SOCKET); 117 if (m == NULL) 118 goto bad; 119 so = mtod(m, struct socket *); 120 so->so_type = head->so_type; 121 so->so_options = head->so_options &~ SO_ACCEPTCONN; 122 so->so_linger = head->so_linger; 123 so->so_state = head->so_state | SS_NOFDREF; 124 so->so_proto = head->so_proto; 125 so->so_timeo = head->so_timeo; 126 so->so_pgrp = head->so_pgrp; 127 soqinsque(head, so, 0); 128 if ((*so->so_proto->pr_usrreq)(so, PRU_ATTACH, 129 (struct mbuf *)0, (struct mbuf *)0, (struct mbuf *)0)) { 130 (void) soqremque(so, 0); 131 (void) m_free(m); 132 goto bad; 133 } 134 return (so); 135 bad: 136 return ((struct socket *)0); 137 } 138 139 soqinsque(head, so, q) 140 register struct socket *head, *so; 141 int q; 142 { 143 144 so->so_head = head; 145 if (q == 0) { 146 head->so_q0len++; 147 so->so_q0 = head->so_q0; 148 head->so_q0 = so; 149 } else { 150 head->so_qlen++; 151 so->so_q = head->so_q; 152 head->so_q = so; 153 } 154 } 155 156 soqremque(so, q) 157 register struct socket *so; 158 int q; 159 { 160 register struct socket *head, *prev, *next; 161 162 head = so->so_head; 163 prev = head; 164 for (;;) { 165 next = q ? prev->so_q : prev->so_q0; 166 if (next == so) 167 break; 168 if (next == head) 169 return (0); 170 prev = next; 171 } 172 if (q == 0) { 173 prev->so_q0 = next->so_q0; 174 head->so_q0len--; 175 } else { 176 prev->so_q = next->so_q; 177 head->so_qlen--; 178 } 179 next->so_q0 = next->so_q = 0; 180 next->so_head = 0; 181 return (1); 182 } 183 184 /* 185 * Socantsendmore indicates that no more data will be sent on the 186 * socket; it would normally be applied to a socket when the user 187 * informs the system that no more data is to be sent, by the protocol 188 * code (in case PRU_SHUTDOWN). Socantrcvmore indicates that no more data 189 * will be received, and will normally be applied to the socket by a 190 * protocol when it detects that the peer will send no more data. 191 * Data queued for reading in the socket may yet be read. 192 */ 193 194 socantsendmore(so) 195 struct socket *so; 196 { 197 198 so->so_state |= SS_CANTSENDMORE; 199 sowwakeup(so); 200 } 201 202 socantrcvmore(so) 203 struct socket *so; 204 { 205 206 so->so_state |= SS_CANTRCVMORE; 207 sorwakeup(so); 208 } 209 210 /* 211 * Socket select/wakeup routines. 212 */ 213 214 /* 215 * Queue a process for a select on a socket buffer. 216 */ 217 sbselqueue(sb) 218 struct sockbuf *sb; 219 { 220 register struct proc *p; 221 222 if ((p = sb->sb_sel) && p->p_wchan == (caddr_t)&selwait) 223 sb->sb_flags |= SB_COLL; 224 else 225 sb->sb_sel = u.u_procp; 226 } 227 228 /* 229 * Wait for data to arrive at/drain from a socket buffer. 230 */ 231 sbwait(sb) 232 struct sockbuf *sb; 233 { 234 235 sb->sb_flags |= SB_WAIT; 236 sleep((caddr_t)&sb->sb_cc, PZERO+1); 237 } 238 239 /* 240 * Wakeup processes waiting on a socket buffer. 241 */ 242 sbwakeup(sb) 243 register struct sockbuf *sb; 244 { 245 246 if (sb->sb_sel) { 247 selwakeup(sb->sb_sel, sb->sb_flags & SB_COLL); 248 sb->sb_sel = 0; 249 sb->sb_flags &= ~SB_COLL; 250 } 251 if (sb->sb_flags & SB_WAIT) { 252 sb->sb_flags &= ~SB_WAIT; 253 wakeup((caddr_t)&sb->sb_cc); 254 } 255 } 256 257 /* 258 * Wakeup socket readers and writers. 259 * Do asynchronous notification via SIGIO 260 * if the socket has the SS_ASYNC flag set. 261 */ 262 sowakeup(so, sb) 263 register struct socket *so; 264 struct sockbuf *sb; 265 { 266 register struct proc *p; 267 268 sbwakeup(sb); 269 if (so->so_state & SS_ASYNC) { 270 if (so->so_pgrp == 0) 271 return; 272 else if (so->so_pgrp > 0) 273 gsignal(so->so_pgrp, SIGIO); 274 else if ((p = pfind(-so->so_pgrp)) != 0) 275 psignal(p, SIGIO); 276 } 277 } 278 279 /* 280 * Socket buffer (struct sockbuf) utility routines. 281 * 282 * Each socket contains two socket buffers: one for sending data and 283 * one for receiving data. Each buffer contains a queue of mbufs, 284 * information about the number of mbufs and amount of data in the 285 * queue, and other fields allowing select() statements and notification 286 * on data availability to be implemented. 287 * 288 * Before using a new socket structure it is first necessary to reserve 289 * buffer space to the socket, by calling sbreserve. This commits 290 * some of the available buffer space in the system buffer pool for the 291 * socket. The space should be released by calling sbrelease when the 292 * socket is destroyed. 293 * 294 * The routine sbappend() is normally called to append new mbufs 295 * to a socket buffer, after checking that adequate space is available 296 * comparing the function spspace() with the amount of data to be added. 297 * Data is normally removed from a socket buffer in a protocol by 298 * first calling m_copy on the socket buffer mbuf chain and sending this 299 * to a peer, and then removing the data from the socket buffer with 300 * sbdrop when the data is acknowledged by the peer (or immediately 301 * in the case of unreliable protocols.) 302 * 303 * Protocols which do not require connections place both source address 304 * and data information in socket buffer queues. The source addresses 305 * are stored in single mbufs after each data item, and are easily found 306 * as the data items are all marked with end of record markers. The 307 * sbappendaddr() routine stores a datum and associated address in 308 * a socket buffer. Note that, unlike sbappend(), this routine checks 309 * for the caller that there will be enough space to store the data. 310 * It fails if there is not enough space, or if it cannot find 311 * a mbuf to store the address in. 312 * 313 * The higher-level routines sosend and soreceive (in socket.c) 314 * also add data to, and remove data from socket buffers repectively. 315 */ 316 317 soreserve(so, sndcc, rcvcc) 318 register struct socket *so; 319 int sndcc, rcvcc; 320 { 321 322 if (sbreserve(&so->so_snd, sndcc) == 0) 323 goto bad; 324 if (sbreserve(&so->so_rcv, rcvcc) == 0) 325 goto bad2; 326 return (0); 327 bad2: 328 sbrelease(&so->so_snd); 329 bad: 330 return (ENOBUFS); 331 } 332 333 /* 334 * Allot mbufs to a sockbuf. 335 */ 336 sbreserve(sb, cc) 337 struct sockbuf *sb; 338 { 339 340 /* someday maybe this routine will fail... */ 341 sb->sb_hiwat = cc; 342 /* * 2 implies names can be no more than 1 mbuf each */ 343 sb->sb_mbmax = cc<<1; 344 return (1); 345 } 346 347 /* 348 * Free mbufs held by a socket, and reserved mbuf space. 349 */ 350 sbrelease(sb) 351 struct sockbuf *sb; 352 { 353 354 sbflush(sb); 355 sb->sb_hiwat = sb->sb_mbmax = 0; 356 } 357 358 /* 359 * Routines to add (at the end) and remove (from the beginning) 360 * data from a mbuf queue. 361 */ 362 363 /* 364 * Append mbuf queue m to sockbuf sb. 365 */ 366 sbappend(sb, m) 367 register struct mbuf *m; 368 register struct sockbuf *sb; 369 { 370 register struct mbuf *n; 371 372 n = sb->sb_mb; 373 if (n) 374 while (n->m_next) 375 n = n->m_next; 376 while (m) { 377 if (m->m_len == 0 && (int)m->m_act == 0) { 378 m = m_free(m); 379 continue; 380 } 381 if (n && n->m_off <= MMAXOFF && m->m_off <= MMAXOFF && 382 (int)n->m_act == 0 && (int)m->m_act == 0 && 383 (n->m_off + n->m_len + m->m_len) <= MMAXOFF) { 384 bcopy(mtod(m, caddr_t), mtod(n, caddr_t) + n->m_len, 385 (unsigned)m->m_len); 386 n->m_len += m->m_len; 387 sb->sb_cc += m->m_len; 388 m = m_free(m); 389 continue; 390 } 391 sballoc(sb, m); 392 if (n == 0) 393 sb->sb_mb = m; 394 else 395 n->m_next = m; 396 n = m; 397 m = m->m_next; 398 n->m_next = 0; 399 } 400 } 401 402 /* 403 * Append data and address. 404 * Return 0 if no space in sockbuf or if 405 * can't get mbuf to stuff address in. 406 */ 407 sbappendaddr(sb, asa, m0, rights0) 408 struct sockbuf *sb; 409 struct sockaddr *asa; 410 struct mbuf *m0, *rights0; 411 { 412 register struct mbuf *m; 413 register int len = sizeof (struct sockaddr); 414 register struct mbuf *rights; 415 416 if (rights0) 417 len += rights0->m_len; 418 m = m0; 419 if (m == 0) 420 panic("sbappendaddr"); 421 for (;;) { 422 len += m->m_len; 423 if (m->m_next == 0) { 424 m->m_act = (struct mbuf *)1; 425 break; 426 } 427 m = m->m_next; 428 } 429 if (len > sbspace(sb)) 430 return (0); 431 m = m_get(M_DONTWAIT, MT_SONAME); 432 if (m == NULL) 433 return (0); 434 m->m_len = sizeof (struct sockaddr); 435 m->m_act = (struct mbuf *)1; 436 *mtod(m, struct sockaddr *) = *asa; 437 if (rights0 == 0 || rights0->m_len == 0) { 438 rights = m_get(M_DONTWAIT, MT_SONAME); 439 if (rights) 440 rights->m_len = 0; 441 } else 442 rights = m_copy(rights0, 0, rights0->m_len); 443 if (rights == 0) { 444 m_freem(m); 445 return (0); 446 } 447 rights->m_act = (struct mbuf *)1; 448 m->m_next = rights; 449 rights->m_next = m0; 450 sbappend(sb, m); 451 return (1); 452 } 453 454 /* 455 * Free all mbufs on a sockbuf mbuf chain. 456 * Check that resource allocations return to 0. 457 */ 458 sbflush(sb) 459 register struct sockbuf *sb; 460 { 461 462 if (sb->sb_flags & SB_LOCK) 463 panic("sbflush"); 464 if (sb->sb_cc) 465 sbdrop(sb, sb->sb_cc); 466 if (sb->sb_cc || sb->sb_mbcnt || sb->sb_mb) 467 panic("sbflush 2"); 468 } 469 470 /* 471 * Drop data from (the front of) a sockbuf chain. 472 */ 473 sbdrop(sb, len) 474 register struct sockbuf *sb; 475 register int len; 476 { 477 register struct mbuf *m = sb->sb_mb, *mn; 478 479 while (len > 0) { 480 if (m == 0) 481 panic("sbdrop"); 482 if (m->m_len > len) { 483 m->m_len -= len; 484 m->m_off += len; 485 sb->sb_cc -= len; 486 break; 487 } 488 len -= m->m_len; 489 sbfree(sb, m); 490 MFREE(m, mn); 491 m = mn; 492 } 493 sb->sb_mb = m; 494 } 495