ddp_usrreq.c revision 1.56 1 /* $NetBSD: ddp_usrreq.c,v 1.56 2014/07/30 10:04:26 rtr Exp $ */
2
3 /*
4 * Copyright (c) 1990,1991 Regents of The University of Michigan.
5 * All Rights Reserved.
6 *
7 * Permission to use, copy, modify, and distribute this software and
8 * its documentation for any purpose and without fee is hereby granted,
9 * provided that the above copyright notice appears in all copies and
10 * that both that copyright notice and this permission notice appear
11 * in supporting documentation, and that the name of The University
12 * of Michigan not be used in advertising or publicity pertaining to
13 * distribution of the software without specific, written prior
14 * permission. This software is supplied as is without expressed or
15 * implied warranties of any kind.
16 *
17 * This product includes software developed by the University of
18 * California, Berkeley and its contributors.
19 *
20 * Research Systems Unix Group
21 * The University of Michigan
22 * c/o Wesley Craig
23 * 535 W. William Street
24 * Ann Arbor, Michigan
25 * +1-313-764-2278
26 * netatalk (at) umich.edu
27 */
28
29 #include <sys/cdefs.h>
30 __KERNEL_RCSID(0, "$NetBSD: ddp_usrreq.c,v 1.56 2014/07/30 10:04:26 rtr Exp $");
31
32 #include "opt_mbuftrace.h"
33
34 #include <sys/param.h>
35 #include <sys/errno.h>
36 #include <sys/systm.h>
37 #include <sys/mbuf.h>
38 #include <sys/ioctl.h>
39 #include <sys/queue.h>
40 #include <sys/socket.h>
41 #include <sys/socketvar.h>
42 #include <sys/protosw.h>
43 #include <sys/kauth.h>
44 #include <sys/kmem.h>
45 #include <sys/sysctl.h>
46 #include <net/if.h>
47 #include <net/route.h>
48 #include <net/if_ether.h>
49 #include <net/net_stats.h>
50 #include <netinet/in.h>
51
52 #include <netatalk/at.h>
53 #include <netatalk/at_var.h>
54 #include <netatalk/ddp_var.h>
55 #include <netatalk/ddp_private.h>
56 #include <netatalk/aarp.h>
57 #include <netatalk/at_extern.h>
58
59 static void at_pcbdisconnect(struct ddpcb *);
60 static void at_sockaddr(struct ddpcb *, struct mbuf *);
61 static int at_pcbsetaddr(struct ddpcb *, struct mbuf *);
62 static int at_pcbconnect(struct ddpcb *, struct mbuf *);
63 static void ddp_detach(struct socket *);
64
65 struct ifqueue atintrq1, atintrq2;
66 struct ddpcb *ddp_ports[ATPORT_LAST];
67 struct ddpcb *ddpcb = NULL;
68 percpu_t *ddpstat_percpu;
69 struct at_ifaddrhead at_ifaddr; /* Here as inited in this file */
70 u_long ddp_sendspace = DDP_MAXSZ; /* Max ddp size + 1 (ddp_type) */
71 u_long ddp_recvspace = 25 * (587 + sizeof(struct sockaddr_at));
72
73 #ifdef MBUFTRACE
74 struct mowner atalk_rx_mowner = MOWNER_INIT("atalk", "rx");
75 struct mowner atalk_tx_mowner = MOWNER_INIT("atalk", "tx");
76 #endif
77
78 static int
79 ddp_usrreq(struct socket *so, int req, struct mbuf *m, struct mbuf *addr,
80 struct mbuf *rights, struct lwp *l)
81 {
82 struct ddpcb *ddp;
83 int error = 0;
84
85 KASSERT(req != PRU_ATTACH);
86 KASSERT(req != PRU_DETACH);
87 KASSERT(req != PRU_ACCEPT);
88 KASSERT(req != PRU_BIND);
89 KASSERT(req != PRU_LISTEN);
90 KASSERT(req != PRU_CONNECT);
91 KASSERT(req != PRU_CONTROL);
92 KASSERT(req != PRU_SENSE);
93 KASSERT(req != PRU_PEERADDR);
94 KASSERT(req != PRU_SOCKADDR);
95 KASSERT(req != PRU_RCVOOB);
96 KASSERT(req != PRU_SENDOOB);
97
98 ddp = sotoddpcb(so);
99
100 if (req == PRU_PURGEIF) {
101 mutex_enter(softnet_lock);
102 at_purgeif((struct ifnet *) rights);
103 mutex_exit(softnet_lock);
104 return (0);
105 }
106 if (rights && rights->m_len) {
107 error = EINVAL;
108 goto release;
109 }
110 if (ddp == NULL) {
111 error = EINVAL;
112 goto release;
113 }
114 switch (req) {
115 case PRU_DISCONNECT:
116 if (ddp->ddp_fsat.sat_addr.s_node == ATADDR_ANYNODE) {
117 error = ENOTCONN;
118 break;
119 }
120 at_pcbdisconnect(ddp);
121 soisdisconnected(so);
122 break;
123
124 case PRU_SHUTDOWN:
125 socantsendmore(so);
126 break;
127
128 case PRU_SEND:{
129 int s = 0;
130
131 if (addr) {
132 if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT) {
133 error = EISCONN;
134 break;
135 }
136 s = splnet();
137 error = at_pcbconnect(ddp, addr);
138 if (error) {
139 splx(s);
140 break;
141 }
142 } else {
143 if (ddp->ddp_fsat.sat_port == ATADDR_ANYPORT) {
144 error = ENOTCONN;
145 break;
146 }
147 }
148
149 error = ddp_output(m, ddp);
150 m = NULL;
151 if (addr) {
152 at_pcbdisconnect(ddp);
153 splx(s);
154 }
155 }
156 break;
157
158 case PRU_ABORT:
159 soisdisconnected(so);
160 ddp_detach(so);
161 break;
162
163 case PRU_CONNECT2:
164 case PRU_FASTTIMO:
165 case PRU_SLOWTIMO:
166 case PRU_PROTORCV:
167 case PRU_PROTOSEND:
168 error = EOPNOTSUPP;
169 break;
170
171 case PRU_RCVD:
172 /*
173 * Don't mfree. Good architecture...
174 */
175 return (EOPNOTSUPP);
176
177 default:
178 error = EOPNOTSUPP;
179 }
180
181 release:
182 if (m != NULL) {
183 m_freem(m);
184 }
185 return (error);
186 }
187
188 static void
189 at_sockaddr(struct ddpcb *ddp, struct mbuf *addr)
190 {
191 struct sockaddr_at *sat;
192
193 addr->m_len = sizeof(struct sockaddr_at);
194 sat = mtod(addr, struct sockaddr_at *);
195 *sat = ddp->ddp_lsat;
196 }
197
198 static int
199 at_pcbsetaddr(struct ddpcb *ddp, struct mbuf *addr)
200 {
201 struct sockaddr_at lsat, *sat;
202 struct at_ifaddr *aa;
203 struct ddpcb *ddpp;
204
205 if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT) { /* shouldn't be bound */
206 return (EINVAL);
207 }
208 if (addr != 0) { /* validate passed address */
209 sat = mtod(addr, struct sockaddr_at *);
210 if (addr->m_len != sizeof(*sat))
211 return (EINVAL);
212
213 if (sat->sat_family != AF_APPLETALK)
214 return (EAFNOSUPPORT);
215
216 if (sat->sat_addr.s_node != ATADDR_ANYNODE ||
217 sat->sat_addr.s_net != ATADDR_ANYNET) {
218 TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
219 if ((sat->sat_addr.s_net ==
220 AA_SAT(aa)->sat_addr.s_net) &&
221 (sat->sat_addr.s_node ==
222 AA_SAT(aa)->sat_addr.s_node))
223 break;
224 }
225 if (!aa)
226 return (EADDRNOTAVAIL);
227 }
228 if (sat->sat_port != ATADDR_ANYPORT) {
229 int error;
230
231 if (sat->sat_port < ATPORT_FIRST ||
232 sat->sat_port >= ATPORT_LAST)
233 return (EINVAL);
234
235 if (sat->sat_port < ATPORT_RESERVED &&
236 (error = kauth_authorize_network(curlwp->l_cred,
237 KAUTH_NETWORK_BIND, KAUTH_REQ_NETWORK_BIND_PRIVPORT,
238 ddpcb->ddp_socket, sat, NULL)) != 0)
239 return (error);
240 }
241 } else {
242 memset((void *) & lsat, 0, sizeof(struct sockaddr_at));
243 lsat.sat_len = sizeof(struct sockaddr_at);
244 lsat.sat_addr.s_node = ATADDR_ANYNODE;
245 lsat.sat_addr.s_net = ATADDR_ANYNET;
246 lsat.sat_family = AF_APPLETALK;
247 sat = &lsat;
248 }
249
250 if (sat->sat_addr.s_node == ATADDR_ANYNODE &&
251 sat->sat_addr.s_net == ATADDR_ANYNET) {
252 if (TAILQ_EMPTY(&at_ifaddr))
253 return EADDRNOTAVAIL;
254 sat->sat_addr = AA_SAT(TAILQ_FIRST(&at_ifaddr))->sat_addr;
255 }
256 ddp->ddp_lsat = *sat;
257
258 /*
259 * Choose port.
260 */
261 if (sat->sat_port == ATADDR_ANYPORT) {
262 for (sat->sat_port = ATPORT_RESERVED;
263 sat->sat_port < ATPORT_LAST; sat->sat_port++) {
264 if (ddp_ports[sat->sat_port - 1] == 0)
265 break;
266 }
267 if (sat->sat_port == ATPORT_LAST) {
268 return (EADDRNOTAVAIL);
269 }
270 ddp->ddp_lsat.sat_port = sat->sat_port;
271 ddp_ports[sat->sat_port - 1] = ddp;
272 } else {
273 for (ddpp = ddp_ports[sat->sat_port - 1]; ddpp;
274 ddpp = ddpp->ddp_pnext) {
275 if (ddpp->ddp_lsat.sat_addr.s_net ==
276 sat->sat_addr.s_net &&
277 ddpp->ddp_lsat.sat_addr.s_node ==
278 sat->sat_addr.s_node)
279 break;
280 }
281 if (ddpp != NULL)
282 return (EADDRINUSE);
283
284 ddp->ddp_pnext = ddp_ports[sat->sat_port - 1];
285 ddp_ports[sat->sat_port - 1] = ddp;
286 if (ddp->ddp_pnext)
287 ddp->ddp_pnext->ddp_pprev = ddp;
288 }
289
290 return 0;
291 }
292
293 static int
294 at_pcbconnect(struct ddpcb *ddp, struct mbuf *addr)
295 {
296 struct rtentry *rt;
297 const struct sockaddr_at *cdst;
298 struct sockaddr_at *sat = mtod(addr, struct sockaddr_at *);
299 struct route *ro;
300 struct at_ifaddr *aa;
301 struct ifnet *ifp;
302 u_short hintnet = 0, net;
303
304 if (addr->m_len != sizeof(*sat))
305 return EINVAL;
306 if (sat->sat_family != AF_APPLETALK) {
307 return EAFNOSUPPORT;
308 }
309 /*
310 * Under phase 2, network 0 means "the network". We take "the
311 * network" to mean the network the control block is bound to.
312 * If the control block is not bound, there is an error.
313 */
314 if (sat->sat_addr.s_net == ATADDR_ANYNET
315 && sat->sat_addr.s_node != ATADDR_ANYNODE) {
316 if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT) {
317 return EADDRNOTAVAIL;
318 }
319 hintnet = ddp->ddp_lsat.sat_addr.s_net;
320 }
321 ro = &ddp->ddp_route;
322 /*
323 * If we've got an old route for this pcb, check that it is valid.
324 * If we've changed our address, we may have an old "good looking"
325 * route here. Attempt to detect it.
326 */
327 if ((rt = rtcache_validate(ro)) != NULL ||
328 (rt = rtcache_update(ro, 1)) != NULL) {
329 if (hintnet) {
330 net = hintnet;
331 } else {
332 net = sat->sat_addr.s_net;
333 }
334 if ((ifp = rt->rt_ifp) != NULL) {
335 TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
336 if (aa->aa_ifp == ifp &&
337 ntohs(net) >= ntohs(aa->aa_firstnet) &&
338 ntohs(net) <= ntohs(aa->aa_lastnet)) {
339 break;
340 }
341 }
342 } else
343 aa = NULL;
344 cdst = satocsat(rtcache_getdst(ro));
345 if (aa == NULL || (cdst->sat_addr.s_net !=
346 (hintnet ? hintnet : sat->sat_addr.s_net) ||
347 cdst->sat_addr.s_node != sat->sat_addr.s_node)) {
348 rtcache_free(ro);
349 rt = NULL;
350 }
351 }
352 /*
353 * If we've got no route for this interface, try to find one.
354 */
355 if (rt == NULL) {
356 union {
357 struct sockaddr dst;
358 struct sockaddr_at dsta;
359 } u;
360
361 sockaddr_at_init(&u.dsta, &sat->sat_addr, 0);
362 if (hintnet)
363 u.dsta.sat_addr.s_net = hintnet;
364 rt = rtcache_lookup(ro, &u.dst);
365 }
366 /*
367 * Make sure any route that we have has a valid interface.
368 */
369 if (rt != NULL && (ifp = rt->rt_ifp) != NULL) {
370 TAILQ_FOREACH(aa, &at_ifaddr, aa_list) {
371 if (aa->aa_ifp == ifp)
372 break;
373 }
374 } else
375 aa = NULL;
376 if (aa == NULL)
377 return ENETUNREACH;
378 ddp->ddp_fsat = *sat;
379 if (ddp->ddp_lsat.sat_port == ATADDR_ANYPORT)
380 return at_pcbsetaddr(ddp, NULL);
381 return 0;
382 }
383
384 static void
385 at_pcbdisconnect(struct ddpcb *ddp)
386 {
387 ddp->ddp_fsat.sat_addr.s_net = ATADDR_ANYNET;
388 ddp->ddp_fsat.sat_addr.s_node = ATADDR_ANYNODE;
389 ddp->ddp_fsat.sat_port = ATADDR_ANYPORT;
390 }
391
392 static int
393 ddp_attach(struct socket *so, int proto)
394 {
395 struct ddpcb *ddp;
396 int error;
397
398 KASSERT(sotoddpcb(so) == NULL);
399 sosetlock(so);
400 #ifdef MBUFTRACE
401 so->so_rcv.sb_mowner = &atalk_rx_mowner;
402 so->so_snd.sb_mowner = &atalk_tx_mowner;
403 #endif
404 error = soreserve(so, ddp_sendspace, ddp_recvspace);
405 if (error) {
406 return error;
407 }
408
409 ddp = kmem_zalloc(sizeof(*ddp), KM_SLEEP);
410 ddp->ddp_lsat.sat_port = ATADDR_ANYPORT;
411
412 ddp->ddp_next = ddpcb;
413 ddp->ddp_prev = NULL;
414 ddp->ddp_pprev = NULL;
415 ddp->ddp_pnext = NULL;
416 if (ddpcb) {
417 ddpcb->ddp_prev = ddp;
418 }
419 ddpcb = ddp;
420
421 ddp->ddp_socket = so;
422 so->so_pcb = ddp;
423 return 0;
424 }
425
426 static void
427 ddp_detach(struct socket *so)
428 {
429 struct ddpcb *ddp = sotoddpcb(so);
430
431 soisdisconnected(so);
432 so->so_pcb = NULL;
433 /* sofree drops the lock */
434 sofree(so);
435 mutex_enter(softnet_lock);
436
437 /* remove ddp from ddp_ports list */
438 if (ddp->ddp_lsat.sat_port != ATADDR_ANYPORT &&
439 ddp_ports[ddp->ddp_lsat.sat_port - 1] != NULL) {
440 if (ddp->ddp_pprev != NULL) {
441 ddp->ddp_pprev->ddp_pnext = ddp->ddp_pnext;
442 } else {
443 ddp_ports[ddp->ddp_lsat.sat_port - 1] = ddp->ddp_pnext;
444 }
445 if (ddp->ddp_pnext != NULL) {
446 ddp->ddp_pnext->ddp_pprev = ddp->ddp_pprev;
447 }
448 }
449 rtcache_free(&ddp->ddp_route);
450 if (ddp->ddp_prev) {
451 ddp->ddp_prev->ddp_next = ddp->ddp_next;
452 } else {
453 ddpcb = ddp->ddp_next;
454 }
455 if (ddp->ddp_next) {
456 ddp->ddp_next->ddp_prev = ddp->ddp_prev;
457 }
458 kmem_free(ddp, sizeof(*ddp));
459 }
460
461 static int
462 ddp_accept(struct socket *so, struct mbuf *nam)
463 {
464 KASSERT(solocked(so));
465
466 return EOPNOTSUPP;
467 }
468
469 static int
470 ddp_bind(struct socket *so, struct mbuf *nam)
471 {
472 KASSERT(solocked(so));
473 KASSERT(sotoddpcb(so) != NULL);
474
475 return at_pcbsetaddr(sotoddpcb(so), nam);
476 }
477
478 static int
479 ddp_listen(struct socket *so)
480 {
481 KASSERT(solocked(so));
482
483 return EOPNOTSUPP;
484 }
485
486 static int
487 ddp_connect(struct socket *so, struct mbuf *nam)
488 {
489 struct ddpcb *ddp = sotoddpcb(so);
490 int error = 0;
491
492 KASSERT(solocked(so));
493 KASSERT(ddp != NULL);
494 KASSERT(nam != NULL);
495
496 if (ddp->ddp_fsat.sat_port != ATADDR_ANYPORT)
497 return EISCONN;
498 error = at_pcbconnect(ddp, nam);
499 if (error == 0)
500 soisconnected(so);
501
502 return error;
503 }
504
505 static int
506 ddp_ioctl(struct socket *so, u_long cmd, void *addr, struct ifnet *ifp)
507 {
508 return at_control(cmd, addr, ifp);
509 }
510
511 static int
512 ddp_stat(struct socket *so, struct stat *ub)
513 {
514 KASSERT(solocked(so));
515
516 /* stat: don't bother with a blocksize. */
517 return 0;
518 }
519
520 static int
521 ddp_peeraddr(struct socket *so, struct mbuf *nam)
522 {
523 KASSERT(solocked(so));
524
525 return EOPNOTSUPP;
526 }
527
528 static int
529 ddp_sockaddr(struct socket *so, struct mbuf *nam)
530 {
531 KASSERT(solocked(so));
532 KASSERT(sotoddpcb(so) != NULL);
533 KASSERT(nam != NULL);
534
535 at_sockaddr(sotoddpcb(so), nam);
536 return 0;
537 }
538
539 static int
540 ddp_recvoob(struct socket *so, struct mbuf *m, int flags)
541 {
542 KASSERT(solocked(so));
543
544 return EOPNOTSUPP;
545 }
546
547 static int
548 ddp_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control)
549 {
550 KASSERT(solocked(so));
551
552 if (m)
553 m_freem(m);
554
555 return EOPNOTSUPP;
556 }
557
558 /*
559 * For the moment, this just find the pcb with the correct local address.
560 * In the future, this will actually do some real searching, so we can use
561 * the sender's address to do de-multiplexing on a single port to many
562 * sockets (pcbs).
563 */
564 struct ddpcb *
565 ddp_search(
566 struct sockaddr_at *from,
567 struct sockaddr_at *to,
568 struct at_ifaddr *aa)
569 {
570 struct ddpcb *ddp;
571
572 /*
573 * Check for bad ports.
574 */
575 if (to->sat_port < ATPORT_FIRST || to->sat_port >= ATPORT_LAST)
576 return NULL;
577
578 /*
579 * Make sure the local address matches the sent address. What about
580 * the interface?
581 */
582 for (ddp = ddp_ports[to->sat_port - 1]; ddp; ddp = ddp->ddp_pnext) {
583 /* XXX should we handle 0.YY? */
584
585 /* XXXX.YY to socket on destination interface */
586 if (to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net &&
587 to->sat_addr.s_node == ddp->ddp_lsat.sat_addr.s_node) {
588 break;
589 }
590 /* 0.255 to socket on receiving interface */
591 if (to->sat_addr.s_node == ATADDR_BCAST &&
592 (to->sat_addr.s_net == 0 ||
593 to->sat_addr.s_net == ddp->ddp_lsat.sat_addr.s_net) &&
594 ddp->ddp_lsat.sat_addr.s_net == AA_SAT(aa)->sat_addr.s_net) {
595 break;
596 }
597 /* XXXX.0 to socket on destination interface */
598 if (to->sat_addr.s_net == aa->aa_firstnet &&
599 to->sat_addr.s_node == 0 &&
600 ntohs(ddp->ddp_lsat.sat_addr.s_net) >=
601 ntohs(aa->aa_firstnet) &&
602 ntohs(ddp->ddp_lsat.sat_addr.s_net) <=
603 ntohs(aa->aa_lastnet)) {
604 break;
605 }
606 }
607 return (ddp);
608 }
609
610 /*
611 * Initialize all the ddp & appletalk stuff
612 */
613 void
614 ddp_init(void)
615 {
616
617 ddpstat_percpu = percpu_alloc(sizeof(uint64_t) * DDP_NSTATS);
618
619 TAILQ_INIT(&at_ifaddr);
620 atintrq1.ifq_maxlen = IFQ_MAXLEN;
621 atintrq2.ifq_maxlen = IFQ_MAXLEN;
622
623 MOWNER_ATTACH(&atalk_tx_mowner);
624 MOWNER_ATTACH(&atalk_rx_mowner);
625 MOWNER_ATTACH(&aarp_mowner);
626 }
627
628 PR_WRAP_USRREQS(ddp)
629 #define ddp_attach ddp_attach_wrapper
630 #define ddp_detach ddp_detach_wrapper
631 #define ddp_accept ddp_accept_wrapper
632 #define ddp_bind ddp_bind_wrapper
633 #define ddp_listen ddp_listen_wrapper
634 #define ddp_connect ddp_connect_wrapper
635 #define ddp_ioctl ddp_ioctl_wrapper
636 #define ddp_stat ddp_stat_wrapper
637 #define ddp_peeraddr ddp_peeraddr_wrapper
638 #define ddp_sockaddr ddp_sockaddr_wrapper
639 #define ddp_recvoob ddp_recvoob_wrapper
640 #define ddp_sendoob ddp_sendoob_wrapper
641 #define ddp_usrreq ddp_usrreq_wrapper
642
643 const struct pr_usrreqs ddp_usrreqs = {
644 .pr_attach = ddp_attach,
645 .pr_detach = ddp_detach,
646 .pr_accept = ddp_accept,
647 .pr_bind = ddp_bind,
648 .pr_listen = ddp_listen,
649 .pr_connect = ddp_connect,
650 .pr_ioctl = ddp_ioctl,
651 .pr_stat = ddp_stat,
652 .pr_peeraddr = ddp_peeraddr,
653 .pr_sockaddr = ddp_sockaddr,
654 .pr_recvoob = ddp_recvoob,
655 .pr_sendoob = ddp_sendoob,
656 .pr_generic = ddp_usrreq,
657 };
658
659 static int
660 sysctl_net_atalk_ddp_stats(SYSCTLFN_ARGS)
661 {
662
663 return (NETSTAT_SYSCTL(ddpstat_percpu, DDP_NSTATS));
664 }
665
666 /*
667 * Sysctl for DDP variables.
668 */
669 SYSCTL_SETUP(sysctl_net_atalk_ddp_setup, "sysctl net.atalk.ddp subtree setup")
670 {
671
672 sysctl_createv(clog, 0, NULL, NULL,
673 CTLFLAG_PERMANENT,
674 CTLTYPE_NODE, "atalk", NULL,
675 NULL, 0, NULL, 0,
676 CTL_NET, PF_APPLETALK, CTL_EOL);
677 sysctl_createv(clog, 0, NULL, NULL,
678 CTLFLAG_PERMANENT,
679 CTLTYPE_NODE, "ddp",
680 SYSCTL_DESCR("DDP related settings"),
681 NULL, 0, NULL, 0,
682 CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_EOL);
683
684 sysctl_createv(clog, 0, NULL, NULL,
685 CTLFLAG_PERMANENT,
686 CTLTYPE_STRUCT, "stats",
687 SYSCTL_DESCR("DDP statistics"),
688 sysctl_net_atalk_ddp_stats, 0, NULL, 0,
689 CTL_NET, PF_APPLETALK, ATPROTO_DDP, CTL_CREATE,
690 CTL_EOL);
691 }
692