sctp_sys_calls.c revision 235827 
1/*-
2 * Copyright (c) 2001-2007, by Cisco Systems, Inc. All rights reserved.
3 * Copyright (c) 2008-2012, by Randall Stewart. All rights reserved.
4 * Copyright (c) 2008-2012, by Michael Tuexen. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
8 *
9 * a) Redistributions of source code must retain the above copyright notice,
10 *    this list of conditions and the following disclaimer.
11 *
12 * b) Redistributions in binary form must reproduce the above copyright
13 *    notice, this list of conditions and the following disclaimer in
14 *    the documentation and/or other materials provided with the distribution.
15 *
16 * c) Neither the name of Cisco Systems, Inc. nor the names of its
17 *    contributors may be used to endorse or promote products derived
18 *    from this software without specific prior written permission.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
22 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
30 * THE POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include <sys/cdefs.h>
34__FBSDID("$FreeBSD: head/lib/libc/net/sctp_sys_calls.c 235827 2012-05-23 10:35:40Z tuexen $");
35
36#include <stdio.h>
37#include <string.h>
38#include <errno.h>
39#include <stdlib.h>
40#include <unistd.h>
41#include <sys/types.h>
42#include <sys/socket.h>
43#include <sys/errno.h>
44#include <sys/syscall.h>
45#include <sys/uio.h>
46#include <netinet/in.h>
47#include <arpa/inet.h>
48#include <netinet/sctp_uio.h>
49#include <netinet/sctp.h>
50
51#include <net/if_dl.h>
52
53#ifndef IN6_IS_ADDR_V4MAPPED
54#define IN6_IS_ADDR_V4MAPPED(a)		      \
55	((*(const uint32_t *)(const void *)(&(a)->s6_addr[0]) == 0) &&	\
56	 (*(const uint32_t *)(const void *)(&(a)->s6_addr[4]) == 0) &&	\
57	 (*(const uint32_t *)(const void *)(&(a)->s6_addr[8]) == ntohl(0x0000ffff)))
58#endif
59
60
61#define SCTP_CONTROL_VEC_SIZE_SND   8192
62#define SCTP_CONTROL_VEC_SIZE_RCV  16384
63#define SCTP_STACK_BUF_SIZE         2048
64
65#ifdef SCTP_DEBUG_PRINT_ADDRESS
66
67#define SCTP_STRING_BUF_SZ 256
68
69static void
70SCTPPrintAnAddress(struct sockaddr *a)
71{
72	char stringToPrint[SCTP_STRING_BUF_SZ];
73	u_short prt;
74	char *srcaddr, *txt;
75
76	if (a == NULL) {
77		printf("NULL\n");
78		return;
79	}
80	if (a->sa_family == AF_INET) {
81		srcaddr = (char *)&((struct sockaddr_in *)a)->sin_addr;
82		txt = "IPv4 Address: ";
83		prt = ntohs(((struct sockaddr_in *)a)->sin_port);
84	} else if (a->sa_family == AF_INET6) {
85		srcaddr = (char *)&((struct sockaddr_in6 *)a)->sin6_addr;
86		prt = ntohs(((struct sockaddr_in6 *)a)->sin6_port);
87		txt = "IPv6 Address: ";
88	} else if (a->sa_family == AF_LINK) {
89		int i;
90		char tbuf[SCTP_STRING_BUF_SZ];
91		u_char adbuf[SCTP_STRING_BUF_SZ];
92		struct sockaddr_dl *dl;
93
94		dl = (struct sockaddr_dl *)a;
95		strncpy(tbuf, dl->sdl_data, dl->sdl_nlen);
96		tbuf[dl->sdl_nlen] = 0;
97		printf("Intf:%s (len:%d)Interface index:%d type:%x(%d) ll-len:%d ",
98		    tbuf,
99		    dl->sdl_nlen,
100		    dl->sdl_index,
101		    dl->sdl_type,
102		    dl->sdl_type,
103		    dl->sdl_alen
104		    );
105		memcpy(adbuf, LLADDR(dl), dl->sdl_alen);
106		for (i = 0; i < dl->sdl_alen; i++) {
107			printf("%2.2x", adbuf[i]);
108			if (i < (dl->sdl_alen - 1))
109				printf(":");
110		}
111		printf("\n");
112		return;
113	} else {
114		return;
115	}
116	if (inet_ntop(a->sa_family, srcaddr, stringToPrint, sizeof(stringToPrint))) {
117		if (a->sa_family == AF_INET6) {
118			printf("%s%s:%d scope:%d\n",
119			    txt, stringToPrint, prt,
120			    ((struct sockaddr_in6 *)a)->sin6_scope_id);
121		} else {
122			printf("%s%s:%d\n", txt, stringToPrint, prt);
123		}
124
125	} else {
126		printf("%s unprintable?\n", txt);
127	}
128}
129
130#endif				/* SCTP_DEBUG_PRINT_ADDRESS */
131
132static void
133in6_sin6_2_sin(struct sockaddr_in *sin, struct sockaddr_in6 *sin6)
134{
135	bzero(sin, sizeof(*sin));
136	sin->sin_len = sizeof(struct sockaddr_in);
137	sin->sin_family = AF_INET;
138	sin->sin_port = sin6->sin6_port;
139	sin->sin_addr.s_addr = sin6->sin6_addr.__u6_addr.__u6_addr32[3];
140}
141
142int
143sctp_getaddrlen(sa_family_t family)
144{
145	int ret, sd;
146	socklen_t siz;
147	struct sctp_assoc_value av;
148
149	av.assoc_value = family;
150	siz = sizeof(av);
151#if defined(AF_INET)
152	sd = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);
153#elif defined(AF_INET6)
154	sd = socket(AF_INET6, SOCK_SEQPACKET, IPPROTO_SCTP);
155#else
156	sd = -1;
157#endif
158	if (sd == -1) {
159		return (-1);
160	}
161	ret = getsockopt(sd, IPPROTO_SCTP, SCTP_GET_ADDR_LEN, &av, &siz);
162	close(sd);
163	if (ret == 0) {
164		return ((int)av.assoc_value);
165	} else {
166		return (-1);
167	}
168}
169
170int
171sctp_connectx(int sd, const struct sockaddr *addrs, int addrcnt,
172    sctp_assoc_t * id)
173{
174	char buf[SCTP_STACK_BUF_SIZE];
175	int i, ret, cnt, *aa;
176	char *cpto;
177	const struct sockaddr *at;
178	sctp_assoc_t *p_id;
179	size_t len = sizeof(int);
180
181	/* validate the address count and list */
182	if ((addrs == NULL) || (addrcnt <= 0)) {
183		errno = EINVAL;
184		return (-1);
185	}
186	at = addrs;
187	cnt = 0;
188	cpto = ((caddr_t)buf + sizeof(int));
189	/* validate all the addresses and get the size */
190	for (i = 0; i < addrcnt; i++) {
191		if (at->sa_family == AF_INET) {
192			if (at->sa_len != sizeof(struct sockaddr_in)) {
193				errno = EINVAL;
194				return (-1);
195			}
196			memcpy(cpto, at, at->sa_len);
197			cpto = ((caddr_t)cpto + at->sa_len);
198			len += at->sa_len;
199		} else if (at->sa_family == AF_INET6) {
200			if (at->sa_len != sizeof(struct sockaddr_in6)) {
201				errno = EINVAL;
202				return (-1);
203			}
204			if (IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)at)->sin6_addr)) {
205				len += sizeof(struct sockaddr_in);
206				in6_sin6_2_sin((struct sockaddr_in *)cpto, (struct sockaddr_in6 *)at);
207				cpto = ((caddr_t)cpto + sizeof(struct sockaddr_in));
208				len += sizeof(struct sockaddr_in);
209			} else {
210				memcpy(cpto, at, at->sa_len);
211				cpto = ((caddr_t)cpto + at->sa_len);
212				len += at->sa_len;
213			}
214		} else {
215			errno = EINVAL;
216			return (-1);
217		}
218		if (len > (sizeof(buf) - sizeof(int))) {
219			/* Never enough memory */
220			errno = E2BIG;
221			return (-1);
222		}
223		at = (struct sockaddr *)((caddr_t)at + at->sa_len);
224		cnt++;
225	}
226	/* do we have any? */
227	if (cnt == 0) {
228		errno = EINVAL;
229		return (-1);
230	}
231	aa = (int *)buf;
232	*aa = cnt;
233	ret = setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X, (void *)buf,
234	    (socklen_t) len);
235	if ((ret == 0) && id) {
236		p_id = (sctp_assoc_t *) buf;
237		*id = *p_id;
238	}
239	return (ret);
240}
241
242int
243sctp_bindx(int sd, struct sockaddr *addrs, int addrcnt, int flags)
244{
245	struct sctp_getaddresses *gaddrs;
246	struct sockaddr *sa;
247	struct sockaddr_in *sin;
248	struct sockaddr_in6 *sin6;
249	int i;
250	size_t argsz;
251	uint16_t sport = 0;
252
253	/* validate the flags */
254	if ((flags != SCTP_BINDX_ADD_ADDR) &&
255	    (flags != SCTP_BINDX_REM_ADDR)) {
256		errno = EFAULT;
257		return (-1);
258	}
259	/* validate the address count and list */
260	if ((addrcnt <= 0) || (addrs == NULL)) {
261		errno = EINVAL;
262		return (-1);
263	}
264	argsz = (sizeof(struct sockaddr_storage) +
265	    sizeof(struct sctp_getaddresses));
266	gaddrs = (struct sctp_getaddresses *)calloc(1, argsz);
267	if (gaddrs == NULL) {
268		errno = ENOMEM;
269		return (-1);
270	}
271	/* First pre-screen the addresses */
272	sa = addrs;
273	for (i = 0; i < addrcnt; i++) {
274		if (sa->sa_family == AF_INET) {
275			if (sa->sa_len != sizeof(struct sockaddr_in))
276				goto out_error;
277			sin = (struct sockaddr_in *)sa;
278			if (sin->sin_port) {
279				/* non-zero port, check or save */
280				if (sport) {
281					/* Check against our port */
282					if (sport != sin->sin_port) {
283						goto out_error;
284					}
285				} else {
286					/* save off the port */
287					sport = sin->sin_port;
288				}
289			}
290		} else if (sa->sa_family == AF_INET6) {
291			if (sa->sa_len != sizeof(struct sockaddr_in6))
292				goto out_error;
293			sin6 = (struct sockaddr_in6 *)sa;
294			if (sin6->sin6_port) {
295				/* non-zero port, check or save */
296				if (sport) {
297					/* Check against our port */
298					if (sport != sin6->sin6_port) {
299						goto out_error;
300					}
301				} else {
302					/* save off the port */
303					sport = sin6->sin6_port;
304				}
305			}
306		} else {
307			/* invalid address family specified */
308			goto out_error;
309		}
310
311		sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
312	}
313	sa = addrs;
314	/*
315	 * Now if there was a port mentioned, assure that the first address
316	 * has that port to make sure it fails or succeeds correctly.
317	 */
318	if (sport) {
319		sin = (struct sockaddr_in *)sa;
320		sin->sin_port = sport;
321	}
322	for (i = 0; i < addrcnt; i++) {
323		if (sa->sa_family == AF_INET) {
324			if (sa->sa_len != sizeof(struct sockaddr_in))
325				goto out_error;
326		} else if (sa->sa_family == AF_INET6) {
327			if (sa->sa_len != sizeof(struct sockaddr_in6))
328				goto out_error;
329		} else {
330			/* invalid address family specified */
331	out_error:
332			free(gaddrs);
333			errno = EINVAL;
334			return (-1);
335		}
336		memset(gaddrs, 0, argsz);
337		gaddrs->sget_assoc_id = 0;
338		memcpy(gaddrs->addr, sa, sa->sa_len);
339		if (setsockopt(sd, IPPROTO_SCTP, flags, gaddrs,
340		    (socklen_t) argsz) != 0) {
341			free(gaddrs);
342			return (-1);
343		}
344		sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
345	}
346	free(gaddrs);
347	return (0);
348}
349
350
351int
352sctp_opt_info(int sd, sctp_assoc_t id, int opt, void *arg, socklen_t * size)
353{
354	if (arg == NULL) {
355		errno = EINVAL;
356		return (-1);
357	}
358	switch (opt) {
359	case SCTP_RTOINFO:
360		((struct sctp_rtoinfo *)arg)->srto_assoc_id = id;
361		break;
362	case SCTP_ASSOCINFO:
363		((struct sctp_assocparams *)arg)->sasoc_assoc_id = id;
364		break;
365	case SCTP_DEFAULT_SEND_PARAM:
366		((struct sctp_assocparams *)arg)->sasoc_assoc_id = id;
367		break;
368	case SCTP_PRIMARY_ADDR:
369		((struct sctp_setprim *)arg)->ssp_assoc_id = id;
370		break;
371	case SCTP_PEER_ADDR_PARAMS:
372		((struct sctp_paddrparams *)arg)->spp_assoc_id = id;
373		break;
374	case SCTP_MAXSEG:
375		((struct sctp_assoc_value *)arg)->assoc_id = id;
376		break;
377	case SCTP_AUTH_KEY:
378		((struct sctp_authkey *)arg)->sca_assoc_id = id;
379		break;
380	case SCTP_AUTH_ACTIVE_KEY:
381		((struct sctp_authkeyid *)arg)->scact_assoc_id = id;
382		break;
383	case SCTP_DELAYED_SACK:
384		((struct sctp_sack_info *)arg)->sack_assoc_id = id;
385		break;
386	case SCTP_CONTEXT:
387		((struct sctp_assoc_value *)arg)->assoc_id = id;
388		break;
389	case SCTP_STATUS:
390		((struct sctp_status *)arg)->sstat_assoc_id = id;
391		break;
392	case SCTP_GET_PEER_ADDR_INFO:
393		((struct sctp_paddrinfo *)arg)->spinfo_assoc_id = id;
394		break;
395	case SCTP_PEER_AUTH_CHUNKS:
396		((struct sctp_authchunks *)arg)->gauth_assoc_id = id;
397		break;
398	case SCTP_LOCAL_AUTH_CHUNKS:
399		((struct sctp_authchunks *)arg)->gauth_assoc_id = id;
400		break;
401	case SCTP_TIMEOUTS:
402		((struct sctp_timeouts *)arg)->stimo_assoc_id = id;
403		break;
404	case SCTP_EVENT:
405		((struct sctp_event *)arg)->se_assoc_id = id;
406		break;
407	case SCTP_DEFAULT_SNDINFO:
408		((struct sctp_sndinfo *)arg)->snd_assoc_id = id;
409		break;
410	case SCTP_DEFAULT_PRINFO:
411		((struct sctp_default_prinfo *)arg)->pr_assoc_id = id;
412		break;
413	case SCTP_PEER_ADDR_THLDS:
414		((struct sctp_paddrthlds *)arg)->spt_assoc_id = id;
415		break;
416	case SCTP_REMOTE_UDP_ENCAPS_PORT:
417		((struct sctp_udpencaps *)arg)->sue_assoc_id = id;
418		break;
419	case SCTP_MAX_BURST:
420		((struct sctp_assoc_value *)arg)->assoc_id = id;
421		break;
422	default:
423		break;
424	}
425	return (getsockopt(sd, IPPROTO_SCTP, opt, arg, size));
426}
427
428int
429sctp_getpaddrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
430{
431	struct sctp_getaddresses *addrs;
432	struct sockaddr *sa;
433	sctp_assoc_t asoc;
434	caddr_t lim;
435	socklen_t opt_len;
436	int cnt;
437
438	if (raddrs == NULL) {
439		errno = EFAULT;
440		return (-1);
441	}
442	asoc = id;
443	opt_len = (socklen_t) sizeof(sctp_assoc_t);
444	if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_REMOTE_ADDR_SIZE,
445	    &asoc, &opt_len) != 0) {
446		return (-1);
447	}
448	/* size required is returned in 'asoc' */
449	opt_len = (socklen_t) ((size_t)asoc + sizeof(struct sctp_getaddresses));
450	addrs = calloc(1, (size_t)opt_len);
451	if (addrs == NULL) {
452		return (-1);
453	}
454	addrs->sget_assoc_id = id;
455	/* Now lets get the array of addresses */
456	if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_PEER_ADDRESSES,
457	    addrs, &opt_len) != 0) {
458		free(addrs);
459		return (-1);
460	}
461	*raddrs = (struct sockaddr *)&addrs->addr[0];
462	cnt = 0;
463	sa = (struct sockaddr *)&addrs->addr[0];
464	lim = (caddr_t)addrs + opt_len;
465	while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
466		sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
467		cnt++;
468	}
469	return (cnt);
470}
471
472void
473sctp_freepaddrs(struct sockaddr *addrs)
474{
475	/* Take away the hidden association id */
476	void *fr_addr;
477
478	fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
479	/* Now free it */
480	free(fr_addr);
481}
482
483int
484sctp_getladdrs(int sd, sctp_assoc_t id, struct sockaddr **raddrs)
485{
486	struct sctp_getaddresses *addrs;
487	caddr_t lim;
488	struct sockaddr *sa;
489	size_t size_of_addresses;
490	socklen_t opt_len;
491	int cnt;
492
493	if (raddrs == NULL) {
494		errno = EFAULT;
495		return (-1);
496	}
497	size_of_addresses = 0;
498	opt_len = (socklen_t) sizeof(int);
499	if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDR_SIZE,
500	    &size_of_addresses, &opt_len) != 0) {
501		errno = ENOMEM;
502		return (-1);
503	}
504	if (size_of_addresses == 0) {
505		errno = ENOTCONN;
506		return (-1);
507	}
508	opt_len = (socklen_t) (size_of_addresses +
509	    sizeof(struct sockaddr_storage) +
510	    sizeof(struct sctp_getaddresses));
511	addrs = calloc(1, (size_t)opt_len);
512	if (addrs == NULL) {
513		errno = ENOMEM;
514		return (-1);
515	}
516	addrs->sget_assoc_id = id;
517	/* Now lets get the array of addresses */
518	if (getsockopt(sd, IPPROTO_SCTP, SCTP_GET_LOCAL_ADDRESSES, addrs,
519	    &opt_len) != 0) {
520		free(addrs);
521		errno = ENOMEM;
522		return (-1);
523	}
524	*raddrs = (struct sockaddr *)&addrs->addr[0];
525	cnt = 0;
526	sa = (struct sockaddr *)&addrs->addr[0];
527	lim = (caddr_t)addrs + opt_len;
528	while (((caddr_t)sa < lim) && (sa->sa_len > 0)) {
529		sa = (struct sockaddr *)((caddr_t)sa + sa->sa_len);
530		cnt++;
531	}
532	return (cnt);
533}
534
535void
536sctp_freeladdrs(struct sockaddr *addrs)
537{
538	/* Take away the hidden association id */
539	void *fr_addr;
540
541	fr_addr = (void *)((caddr_t)addrs - sizeof(sctp_assoc_t));
542	/* Now free it */
543	free(fr_addr);
544}
545
546
547ssize_t
548sctp_sendmsg(int s,
549    const void *data,
550    size_t len,
551    const struct sockaddr *to,
552    socklen_t tolen,
553    uint32_t ppid,
554    uint32_t flags,
555    uint16_t stream_no,
556    uint32_t timetolive,
557    uint32_t context)
558{
559#ifdef SYS_sctp_generic_sendmsg
560	struct sctp_sndrcvinfo sinfo;
561
562	memset(&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
563	sinfo.sinfo_ppid = ppid;
564	sinfo.sinfo_flags = flags;
565	sinfo.sinfo_stream = stream_no;
566	sinfo.sinfo_timetolive = timetolive;
567	sinfo.sinfo_context = context;
568	sinfo.sinfo_assoc_id = 0;
569	return (syscall(SYS_sctp_generic_sendmsg, s,
570	    data, len, to, tolen, &sinfo, 0));
571#else
572	ssize_t sz;
573	struct msghdr msg;
574	struct sctp_sndrcvinfo *s_info;
575	struct iovec iov;
576	char controlVector[SCTP_CONTROL_VEC_SIZE_RCV];
577	struct cmsghdr *cmsg;
578	struct sockaddr *who = NULL;
579	union {
580		struct sockaddr_in in;
581		struct sockaddr_in6 in6;
582	}     addr;
583
584	if ((tolen > 0) &&
585	    ((to == NULL) || (tolen < sizeof(struct sockaddr)))) {
586		errno = EINVAL;
587		return -1;
588	}
589	if (to && (tolen > 0)) {
590		if (to->sa_family == AF_INET) {
591			if (tolen != sizeof(struct sockaddr_in)) {
592				errno = EINVAL;
593				return -1;
594			}
595			if ((to->sa_len > 0) &&
596			    (to->sa_len != sizeof(struct sockaddr_in))) {
597				errno = EINVAL;
598				return -1;
599			}
600			memcpy(&addr, to, sizeof(struct sockaddr_in));
601			addr.in.sin_len = sizeof(struct sockaddr_in);
602		} else if (to->sa_family == AF_INET6) {
603			if (tolen != sizeof(struct sockaddr_in6)) {
604				errno = EINVAL;
605				return -1;
606			}
607			if ((to->sa_len > 0) &&
608			    (to->sa_len != sizeof(struct sockaddr_in6))) {
609				errno = EINVAL;
610				return -1;
611			}
612			memcpy(&addr, to, sizeof(struct sockaddr_in6));
613			addr.in6.sin6_len = sizeof(struct sockaddr_in6);
614		} else {
615			errno = EAFNOSUPPORT;
616			return -1;
617		}
618		who = (struct sockaddr *)&addr;
619	}
620	iov.iov_base = (char *)data;
621	iov.iov_len = len;
622
623	if (who) {
624		msg.msg_name = (caddr_t)who;
625		msg.msg_namelen = who->sa_len;
626	} else {
627		msg.msg_name = (caddr_t)NULL;
628		msg.msg_namelen = 0;
629	}
630	msg.msg_iov = &iov;
631	msg.msg_iovlen = 1;
632	msg.msg_control = (caddr_t)controlVector;
633
634	cmsg = (struct cmsghdr *)controlVector;
635
636	cmsg->cmsg_level = IPPROTO_SCTP;
637	cmsg->cmsg_type = SCTP_SNDRCV;
638	cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
639	s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
640
641	s_info->sinfo_stream = stream_no;
642	s_info->sinfo_ssn = 0;
643	s_info->sinfo_flags = flags;
644	s_info->sinfo_ppid = ppid;
645	s_info->sinfo_context = context;
646	s_info->sinfo_assoc_id = 0;
647	s_info->sinfo_timetolive = timetolive;
648	errno = 0;
649	msg.msg_controllen = cmsg->cmsg_len;
650	sz = sendmsg(s, &msg, 0);
651	return (sz);
652#endif
653}
654
655
656sctp_assoc_t
657sctp_getassocid(int sd, struct sockaddr *sa)
658{
659	struct sctp_paddrinfo sp;
660	socklen_t siz;
661
662	/* First get the assoc id */
663	siz = sizeof(sp);
664	memset(&sp, 0, sizeof(sp));
665	memcpy((caddr_t)&sp.spinfo_address, sa, sa->sa_len);
666	errno = 0;
667	if (getsockopt(sd, IPPROTO_SCTP,
668	    SCTP_GET_PEER_ADDR_INFO, &sp, &siz) != 0) {
669		return ((sctp_assoc_t) 0);
670	}
671	/* We depend on the fact that 0 can never be returned */
672	return (sp.spinfo_assoc_id);
673}
674
675ssize_t
676sctp_send(int sd, const void *data, size_t len,
677    const struct sctp_sndrcvinfo *sinfo,
678    int flags)
679{
680
681#ifdef SYS_sctp_generic_sendmsg
682	struct sockaddr *to = NULL;
683
684	return (syscall(SYS_sctp_generic_sendmsg, sd,
685	    data, len, to, 0, sinfo, flags));
686#else
687	ssize_t sz;
688	struct msghdr msg;
689	struct iovec iov;
690	struct sctp_sndrcvinfo *s_info;
691	char controlVector[SCTP_CONTROL_VEC_SIZE_SND];
692	struct cmsghdr *cmsg;
693
694	if (sinfo == NULL) {
695		errno = EINVAL;
696		return (-1);
697	}
698	iov.iov_base = (char *)data;
699	iov.iov_len = len;
700
701	msg.msg_name = 0;
702	msg.msg_namelen = 0;
703	msg.msg_iov = &iov;
704	msg.msg_iovlen = 1;
705	msg.msg_control = (caddr_t)controlVector;
706
707	cmsg = (struct cmsghdr *)controlVector;
708
709	cmsg->cmsg_level = IPPROTO_SCTP;
710	cmsg->cmsg_type = SCTP_SNDRCV;
711	cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndrcvinfo));
712	s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
713	/* copy in the data */
714	*s_info = *sinfo;
715	errno = 0;
716	msg.msg_controllen = cmsg->cmsg_len;
717	sz = sendmsg(sd, &msg, flags);
718	return (sz);
719#endif
720}
721
722
723
724ssize_t
725sctp_sendx(int sd, const void *msg, size_t msg_len,
726    struct sockaddr *addrs, int addrcnt,
727    struct sctp_sndrcvinfo *sinfo,
728    int flags)
729{
730	struct sctp_sndrcvinfo __sinfo;
731	ssize_t ret;
732	int i, cnt, *aa, saved_errno;
733	char *buf;
734	int no_end_cx = 0;
735	size_t len, add_len;
736	struct sockaddr *at;
737
738	if (addrs == NULL) {
739		errno = EINVAL;
740		return (-1);
741	}
742#ifdef SYS_sctp_generic_sendmsg
743	if (addrcnt == 1) {
744		socklen_t l;
745
746		/*
747		 * Quick way, we don't need to do a connectx so lets use the
748		 * syscall directly.
749		 */
750		l = addrs->sa_len;
751		return (syscall(SYS_sctp_generic_sendmsg, sd,
752		    msg, msg_len, addrs, l, sinfo, flags));
753	}
754#endif
755
756	len = sizeof(int);
757	at = addrs;
758	cnt = 0;
759	/* validate all the addresses and get the size */
760	for (i = 0; i < addrcnt; i++) {
761		if (at->sa_family == AF_INET) {
762			add_len = sizeof(struct sockaddr_in);
763		} else if (at->sa_family == AF_INET6) {
764			add_len = sizeof(struct sockaddr_in6);
765		} else {
766			errno = EINVAL;
767			return (-1);
768		}
769		len += add_len;
770		at = (struct sockaddr *)((caddr_t)at + add_len);
771		cnt++;
772	}
773	/* do we have any? */
774	if (cnt == 0) {
775		errno = EINVAL;
776		return (-1);
777	}
778	buf = malloc(len);
779	if (buf == NULL) {
780		return (-1);
781	}
782	aa = (int *)buf;
783	*aa = cnt;
784	aa++;
785	memcpy((caddr_t)aa, addrs, (size_t)(len - sizeof(int)));
786	ret = setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_DELAYED, (void *)buf,
787	    (socklen_t) len);
788
789	free(buf);
790	if (ret != 0) {
791		if (errno == EALREADY) {
792			no_end_cx = 1;
793			goto continue_send;
794		}
795		return (ret);
796	}
797continue_send:
798	if (sinfo == NULL) {
799		sinfo = &__sinfo;
800		memset(&__sinfo, 0, sizeof(__sinfo));
801	}
802	sinfo->sinfo_assoc_id = sctp_getassocid(sd, addrs);
803	if (sinfo->sinfo_assoc_id == 0) {
804		(void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
805		    (socklen_t) addrs->sa_len);
806		errno = ENOENT;
807		return (-1);
808	}
809	ret = sctp_send(sd, msg, msg_len, sinfo, flags);
810	saved_errno = errno;
811	if (no_end_cx == 0)
812		(void)setsockopt(sd, IPPROTO_SCTP, SCTP_CONNECT_X_COMPLETE, (void *)addrs,
813		    (socklen_t) addrs->sa_len);
814
815	errno = saved_errno;
816	return (ret);
817}
818
819ssize_t
820sctp_sendmsgx(int sd,
821    const void *msg,
822    size_t len,
823    struct sockaddr *addrs,
824    int addrcnt,
825    uint32_t ppid,
826    uint32_t flags,
827    uint16_t stream_no,
828    uint32_t timetolive,
829    uint32_t context)
830{
831	struct sctp_sndrcvinfo sinfo;
832
833	memset((void *)&sinfo, 0, sizeof(struct sctp_sndrcvinfo));
834	sinfo.sinfo_ppid = ppid;
835	sinfo.sinfo_flags = flags;
836	sinfo.sinfo_ssn = stream_no;
837	sinfo.sinfo_timetolive = timetolive;
838	sinfo.sinfo_context = context;
839	return sctp_sendx(sd, msg, len, addrs, addrcnt, &sinfo, 0);
840}
841
842ssize_t
843sctp_recvmsg(int s,
844    void *dbuf,
845    size_t len,
846    struct sockaddr *from,
847    socklen_t * fromlen,
848    struct sctp_sndrcvinfo *sinfo,
849    int *msg_flags)
850{
851#ifdef SYS_sctp_generic_recvmsg
852	struct iovec iov;
853
854	iov.iov_base = dbuf;
855	iov.iov_len = len;
856	return (syscall(SYS_sctp_generic_recvmsg, s,
857	    &iov, 1, from, fromlen, sinfo, msg_flags));
858#else
859	struct sctp_sndrcvinfo *s_info;
860	ssize_t sz;
861	struct msghdr msg;
862	struct iovec iov;
863	char controlVector[SCTP_CONTROL_VEC_SIZE_RCV];
864	struct cmsghdr *cmsg;
865
866	if (msg_flags == NULL) {
867		errno = EINVAL;
868		return (-1);
869	}
870	msg.msg_flags = 0;
871	iov.iov_base = dbuf;
872	iov.iov_len = len;
873	msg.msg_name = (caddr_t)from;
874	if (fromlen == NULL)
875		msg.msg_namelen = 0;
876	else
877		msg.msg_namelen = *fromlen;
878	msg.msg_iov = &iov;
879	msg.msg_iovlen = 1;
880	msg.msg_control = (caddr_t)controlVector;
881	msg.msg_controllen = sizeof(controlVector);
882	errno = 0;
883	sz = recvmsg(s, &msg, *msg_flags);
884	*msg_flags = msg.msg_flags;
885	if (sz <= 0) {
886		return (sz);
887	}
888	s_info = NULL;
889	if (sinfo) {
890		sinfo->sinfo_assoc_id = 0;
891	}
892	if ((msg.msg_controllen) && sinfo) {
893		/*
894		 * parse through and see if we find the sctp_sndrcvinfo (if
895		 * the user wants it).
896		 */
897		cmsg = (struct cmsghdr *)controlVector;
898		while (cmsg) {
899			if ((cmsg->cmsg_len == 0) || (cmsg->cmsg_len > msg.msg_controllen)) {
900				break;
901			}
902			if (cmsg->cmsg_level == IPPROTO_SCTP) {
903				if (cmsg->cmsg_type == SCTP_SNDRCV) {
904					/* Got it */
905					s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
906					/* Copy it to the user */
907					if (sinfo)
908						*sinfo = *s_info;
909					break;
910				} else if (cmsg->cmsg_type == SCTP_EXTRCV) {
911					/*
912					 * Got it, presumably the user has
913					 * asked for this extra info, so the
914					 * structure holds more room :-D
915					 */
916					s_info = (struct sctp_sndrcvinfo *)CMSG_DATA(cmsg);
917					/* Copy it to the user */
918					if (sinfo) {
919						memcpy(sinfo, s_info, sizeof(struct sctp_extrcvinfo));
920					}
921					break;
922
923				}
924			}
925			cmsg = CMSG_NXTHDR(&msg, cmsg);
926		}
927	}
928	return (sz);
929#endif
930}
931
932ssize_t
933sctp_recvv(int sd,
934    const struct iovec *iov,
935    int iovlen,
936    struct sockaddr *from,
937    socklen_t * fromlen,
938    void *info,
939    socklen_t * infolen,
940    unsigned int *infotype,
941    int *flags)
942{
943	char ctlbuf[SCTP_CONTROL_VEC_SIZE_RCV];
944	struct msghdr msg;
945	struct cmsghdr *cmsg;
946	ssize_t n;
947	struct sctp_rcvinfo *rcvinfo;
948	struct sctp_nxtinfo *nxtinfo;
949
950	if (((info != NULL) && (infolen == NULL)) |
951	    ((info == NULL) && (infolen != NULL) && (*infolen != 0)) ||
952	    ((info != NULL) && (infotype == NULL))) {
953		errno = EINVAL;
954		return (-1);
955	}
956	if (infotype) {
957		*infotype = SCTP_RECVV_NOINFO;
958	}
959	msg.msg_name = from;
960	if (fromlen == NULL) {
961		msg.msg_namelen = 0;
962	} else {
963		msg.msg_namelen = *fromlen;
964	}
965	msg.msg_iov = (struct iovec *)iov;
966	msg.msg_iovlen = iovlen;
967	msg.msg_control = ctlbuf;
968	msg.msg_controllen = sizeof(ctlbuf);
969	errno = 0;
970	n = recvmsg(sd, &msg, *flags);
971	*flags = msg.msg_flags;
972	if ((n > 0) &&
973	    (msg.msg_controllen > 0) &&
974	    (infotype != NULL) &&
975	    (infolen != NULL) &&
976	    (*infolen > 0)) {
977		rcvinfo = NULL;
978		nxtinfo = NULL;
979		for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
980			if (cmsg->cmsg_level != IPPROTO_SCTP) {
981				continue;
982			}
983			if (cmsg->cmsg_type == SCTP_RCVINFO) {
984				rcvinfo = (struct sctp_rcvinfo *)CMSG_DATA(cmsg);
985			}
986			if (cmsg->cmsg_type == SCTP_NXTINFO) {
987				nxtinfo = (struct sctp_nxtinfo *)CMSG_DATA(cmsg);
988			}
989			if (rcvinfo && nxtinfo) {
990				break;
991			}
992		}
993		if (rcvinfo) {
994			if (nxtinfo) {
995				if (*infolen >= sizeof(struct sctp_recvv_rn)) {
996					struct sctp_recvv_rn *rn_info;
997
998					rn_info = (struct sctp_recvv_rn *)info;
999					rn_info->recvv_rcvinfo = *rcvinfo;
1000					rn_info->recvv_nxtinfo = *nxtinfo;
1001					*infolen = (socklen_t) sizeof(struct sctp_recvv_rn);
1002					*infotype = SCTP_RECVV_RN;
1003				}
1004			} else {
1005				if (*infolen >= sizeof(struct sctp_rcvinfo)) {
1006					memcpy(info, rcvinfo, sizeof(struct sctp_rcvinfo));
1007					*infolen = (socklen_t) sizeof(struct sctp_rcvinfo);
1008					*infotype = SCTP_RECVV_RCVINFO;
1009				}
1010			}
1011		} else if (nxtinfo) {
1012			if (*infolen >= sizeof(struct sctp_rcvinfo)) {
1013				memcpy(info, nxtinfo, sizeof(struct sctp_nxtinfo));
1014				*infolen = (socklen_t) sizeof(struct sctp_nxtinfo);
1015				*infotype = SCTP_RECVV_NXTINFO;
1016			}
1017		}
1018	}
1019	return (n);
1020}
1021
1022ssize_t
1023sctp_sendv(int sd,
1024    const struct iovec *iov, int iovcnt,
1025    struct sockaddr *addrs, int addrcnt,
1026    void *info, socklen_t infolen, unsigned int infotype,
1027    int flags)
1028{
1029	ssize_t ret;
1030	int i;
1031	socklen_t addr_len;
1032	struct msghdr msg;
1033	in_port_t port;
1034	struct sctp_sendv_spa *spa_info;
1035	struct cmsghdr *cmsg;
1036	char *cmsgbuf;
1037	struct sockaddr *addr;
1038	struct sockaddr_in *addr_in;
1039	struct sockaddr_in6 *addr_in6;
1040
1041	if ((addrcnt < 0) ||
1042	    (iovcnt < 0) ||
1043	    ((addrs == NULL) && (addrcnt > 0)) ||
1044	    ((addrs != NULL) && (addrcnt == 0)) ||
1045	    ((iov == NULL) && (iovcnt > 0)) ||
1046	    ((iov != NULL) && (iovcnt == 0))) {
1047		errno = EINVAL;
1048		return (-1);
1049	}
1050	cmsgbuf = malloc(CMSG_SPACE(sizeof(struct sctp_sndinfo)) +
1051	    CMSG_SPACE(sizeof(struct sctp_prinfo)) +
1052	    CMSG_SPACE(sizeof(struct sctp_authinfo)) +
1053	    (size_t)addrcnt * CMSG_SPACE(sizeof(struct in6_addr)));
1054	if (cmsgbuf == NULL) {
1055		errno = ENOBUFS;
1056		return (-1);
1057	}
1058	msg.msg_control = cmsgbuf;
1059	msg.msg_controllen = 0;
1060	cmsg = (struct cmsghdr *)cmsgbuf;
1061	switch (infotype) {
1062	case SCTP_SENDV_NOINFO:
1063		if ((infolen != 0) || (info != NULL)) {
1064			free(cmsgbuf);
1065			errno = EINVAL;
1066			return (-1);
1067		}
1068		break;
1069	case SCTP_SENDV_SNDINFO:
1070		if ((info == NULL) || (infolen < sizeof(struct sctp_sndinfo))) {
1071			free(cmsgbuf);
1072			errno = EINVAL;
1073			return (-1);
1074		}
1075		cmsg->cmsg_level = IPPROTO_SCTP;
1076		cmsg->cmsg_type = SCTP_SNDINFO;
1077		cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1078		memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_sndinfo));
1079		msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1080		cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
1081		break;
1082	case SCTP_SENDV_PRINFO:
1083		if ((info == NULL) || (infolen < sizeof(struct sctp_prinfo))) {
1084			free(cmsgbuf);
1085			errno = EINVAL;
1086			return (-1);
1087		}
1088		cmsg->cmsg_level = IPPROTO_SCTP;
1089		cmsg->cmsg_type = SCTP_PRINFO;
1090		cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1091		memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_prinfo));
1092		msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1093		cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
1094		break;
1095	case SCTP_SENDV_AUTHINFO:
1096		if ((info == NULL) || (infolen < sizeof(struct sctp_authinfo))) {
1097			free(cmsgbuf);
1098			errno = EINVAL;
1099			return (-1);
1100		}
1101		cmsg->cmsg_level = IPPROTO_SCTP;
1102		cmsg->cmsg_type = SCTP_AUTHINFO;
1103		cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1104		memcpy(CMSG_DATA(cmsg), info, sizeof(struct sctp_authinfo));
1105		msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1106		cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1107		break;
1108	case SCTP_SENDV_SPA:
1109		if ((info == NULL) || (infolen < sizeof(struct sctp_sendv_spa))) {
1110			free(cmsgbuf);
1111			errno = EINVAL;
1112			return (-1);
1113		}
1114		spa_info = (struct sctp_sendv_spa *)info;
1115		if (spa_info->sendv_flags & SCTP_SEND_SNDINFO_VALID) {
1116			cmsg->cmsg_level = IPPROTO_SCTP;
1117			cmsg->cmsg_type = SCTP_SNDINFO;
1118			cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_sndinfo));
1119			memcpy(CMSG_DATA(cmsg), &spa_info->sendv_sndinfo, sizeof(struct sctp_sndinfo));
1120			msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_sndinfo));
1121			cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_sndinfo)));
1122		}
1123		if (spa_info->sendv_flags & SCTP_SEND_PRINFO_VALID) {
1124			cmsg->cmsg_level = IPPROTO_SCTP;
1125			cmsg->cmsg_type = SCTP_PRINFO;
1126			cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_prinfo));
1127			memcpy(CMSG_DATA(cmsg), &spa_info->sendv_prinfo, sizeof(struct sctp_prinfo));
1128			msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_prinfo));
1129			cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_prinfo)));
1130		}
1131		if (spa_info->sendv_flags & SCTP_SEND_AUTHINFO_VALID) {
1132			cmsg->cmsg_level = IPPROTO_SCTP;
1133			cmsg->cmsg_type = SCTP_AUTHINFO;
1134			cmsg->cmsg_len = CMSG_LEN(sizeof(struct sctp_authinfo));
1135			memcpy(CMSG_DATA(cmsg), &spa_info->sendv_authinfo, sizeof(struct sctp_authinfo));
1136			msg.msg_controllen += CMSG_SPACE(sizeof(struct sctp_authinfo));
1137			cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct sctp_authinfo)));
1138		}
1139		break;
1140	default:
1141		free(cmsgbuf);
1142		errno = EINVAL;
1143		return (-1);
1144	}
1145	addr = addrs;
1146	msg.msg_name = NULL;
1147	msg.msg_namelen = 0;
1148
1149	for (i = 0; i < addrcnt; i++) {
1150		switch (addr->sa_family) {
1151		case AF_INET:
1152			addr_len = (socklen_t) sizeof(struct sockaddr_in);
1153			addr_in = (struct sockaddr_in *)addr;
1154			if (addr_in->sin_len != addr_len) {
1155				free(cmsgbuf);
1156				errno = EINVAL;
1157				return (-1);
1158			}
1159			if (i == 0) {
1160				port = addr_in->sin_port;
1161			} else {
1162				if (port == addr_in->sin_port) {
1163					cmsg->cmsg_level = IPPROTO_SCTP;
1164					cmsg->cmsg_type = SCTP_DSTADDRV4;
1165					cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
1166					memcpy(CMSG_DATA(cmsg), &addr_in->sin_addr, sizeof(struct in_addr));
1167					msg.msg_controllen += CMSG_SPACE(sizeof(struct in_addr));
1168					cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in_addr)));
1169				} else {
1170					free(cmsgbuf);
1171					errno = EINVAL;
1172					return (-1);
1173				}
1174			}
1175			break;
1176		case AF_INET6:
1177			addr_len = (socklen_t) sizeof(struct sockaddr_in6);
1178			addr_in6 = (struct sockaddr_in6 *)addr;
1179			if (addr_in6->sin6_len != addr_len) {
1180				free(cmsgbuf);
1181				errno = EINVAL;
1182				return (-1);
1183			}
1184			if (i == 0) {
1185				port = addr_in6->sin6_port;
1186			} else {
1187				if (port == addr_in6->sin6_port) {
1188					cmsg->cmsg_level = IPPROTO_SCTP;
1189					cmsg->cmsg_type = SCTP_DSTADDRV6;
1190					cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_addr));
1191					memcpy(CMSG_DATA(cmsg), &addr_in6->sin6_addr, sizeof(struct in6_addr));
1192					msg.msg_controllen += CMSG_SPACE(sizeof(struct in6_addr));
1193					cmsg = (struct cmsghdr *)((caddr_t)cmsg + CMSG_SPACE(sizeof(struct in6_addr)));
1194				} else {
1195					free(cmsgbuf);
1196					errno = EINVAL;
1197					return (-1);
1198				}
1199			}
1200			break;
1201		default:
1202			free(cmsgbuf);
1203			errno = EINVAL;
1204			return (-1);
1205		}
1206		if (i == 0) {
1207			msg.msg_name = addr;
1208			msg.msg_namelen = addr_len;
1209		}
1210		addr = (struct sockaddr *)((caddr_t)addr + addr_len);
1211	}
1212	if (msg.msg_controllen == 0) {
1213		msg.msg_control = NULL;
1214	}
1215	msg.msg_iov = (struct iovec *)iov;
1216	msg.msg_iovlen = iovcnt;
1217	msg.msg_flags = 0;
1218	ret = sendmsg(sd, &msg, flags);
1219	free(cmsgbuf);
1220	return (ret);
1221}
1222
1223
1224#if !defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1225
1226int
1227sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1228{
1229	/* NOT supported, return invalid sd */
1230	errno = ENOTSUP;
1231	return (-1);
1232}
1233
1234#endif
1235#if defined(SYS_sctp_peeloff) && !defined(HAVE_SCTP_PEELOFF_SOCKOPT)
1236int
1237sctp_peeloff(int sd, sctp_assoc_t assoc_id)
1238{
1239	return (syscall(SYS_sctp_peeloff, sd, assoc_id));
1240}
1241
1242#endif
1243
1244
1245#undef SCTP_CONTROL_VEC_SIZE_SND
1246#undef SCTP_CONTROL_VEC_SIZE_RCV
1247#undef SCTP_STACK_BUF_SIZE
1248