1 /* Copyright (C) 2006 Andre Noll <maan@tuebingen.mpg.de>, see file COPYING. */
3 /** \file dccp_send.c Paraslash's dccp sender. */
6 * based on server.c of dccp-cs-0.01.tar.bz2,
7 * (C) 2005 Ian McDonald <imcdnzl@gmail.com>
10 #include <netinet/in.h>
11 #include <sys/socket.h>
13 #include <sys/types.h>
14 #include <arpa/inet.h>
19 #include "server.lsg.h"
32 static struct sender_status dccp_sender_status
, *dss
= &dccp_sender_status
;
34 struct dccp_fec_client
{
35 struct fec_client_parms fcp
;
36 struct fec_client
*fc
;
39 static void dccp_pre_select(int *max_fileno
, fd_set
*rfds
,
40 __a_unused fd_set
*wfds
)
42 if (dss
->listen_fd
>= 0)
43 para_fd_set(dss
->listen_fd
, rfds
, max_fileno
);
47 * Query the TX CCID used on the sender-client half connection.
48 * \param sockfd Server socket descriptor to query (after accept(2)).
49 * \return CCID number > 0, -1 on error/incompatibility.
51 * NB: This feature is only available on Linux > 2.6.30; on older kernels
52 * ENOPROTOOPT ("Protocol not available") will be returned.
54 static int dccp_get_tx_ccid(int sockfd
)
57 socklen_t len
= sizeof(tx_ccid
);
59 if (getsockopt(sockfd
, SOL_DCCP
,
60 DCCP_SOCKOPT_TX_CCID
, &tx_ccid
, &len
) < 0) {
61 PARA_WARNING_LOG("DCCP_SOCKOPT_TX_CCID: %s\n", strerror(errno
));
67 static void dccp_shutdown_client(struct sender_client
*sc
)
69 struct dccp_fec_client
*dfc
= sc
->private_data
;
71 vss_del_fec_client(dfc
->fc
);
72 shutdown_client(sc
, dss
);
75 static void dccp_shutdown_clients(void)
77 struct sender_client
*sc
, *tmp
;
79 list_for_each_entry_safe(sc
, tmp
, &dss
->client_list
, node
)
80 dccp_shutdown_client(sc
);
83 static void dccp_shutdown(void)
85 dccp_shutdown_clients();
86 generic_acl_deplete(&dss
->acl
);
89 /** * Obtain current MPS according to RFC 4340, sec. 14. */
90 static int dccp_init_fec(struct sender_client
*sc
)
93 socklen_t ml
= sizeof(mps
);
94 uint32_t mss
; /* max slize size */
96 /* If call fails, return some sensible minimum value */
97 ret
= getsockopt(sc
->fd
, SOL_DCCP
, DCCP_SOCKOPT_GET_CUR_MPS
, &mps
, &ml
);
99 PARA_NOTICE_LOG("can not determine MPS: %s\n", strerror(errno
));
100 mps
= generic_max_transport_msg_size(sc
->fd
) - DCCP_MAX_HEADER
;
102 PARA_INFO_LOG("current MPS = %d bytes\n", mps
);
104 mss
= OPT_UINT32_VAL(DCCP_MAX_SLICE_SIZE
);
105 if (mss
> 0 && mss
<= INT_MAX
)
106 mps
= PARA_MIN(mps
, (int)mss
);
110 static void dccp_send_fec(struct sender_client
*sc
, char *buf
, size_t len
)
112 int ret
= xwrite(sc
->fd
, buf
, len
);
115 dccp_shutdown_client(sc
);
118 static void dccp_post_select(fd_set
*rfds
, __a_unused fd_set
*wfds
)
120 struct sender_client
*sc
;
121 struct dccp_fec_client
*dfc
;
125 sc
= accept_sender_client(dss
, rfds
);
129 /* If CCID identifiable, present client as <host>#<port>~<ccid> */
130 tx_ccid
= dccp_get_tx_ccid(sc
->fd
);
132 char *tmp
= make_message("%s~%d", sc
->name
, tx_ccid
);
138 * Bypass unused CCID paths: the sender does not receive application data
139 * from the client; by shutting down this unused communication path we can
140 * reduce processing costs a bit. See analogous comment in \ref dccp_recv.c.
142 if (shutdown(sc
->fd
, SHUT_RD
) < 0) {
143 PARA_WARNING_LOG("%s\n", strerror(errno
));
144 shutdown_client(sc
, dss
);
147 dfc
= para_calloc(sizeof(*dfc
));
148 sc
->private_data
= dfc
;
149 k
= OPT_UINT32_VAL(DCCP_DATA_SLICES_PER_GROUP
);
150 n
= OPT_UINT32_VAL(DCCP_SLICES_PER_GROUP
);
151 if (k
== 0 || n
== 0 || k
>= n
) {
152 PARA_WARNING_LOG("invalid FEC parameters, using defaults\n");
153 dfc
->fcp
.data_slices_per_group
= 3;
154 dfc
->fcp
.slices_per_group
= 4;
156 dfc
->fcp
.data_slices_per_group
= k
;
157 dfc
->fcp
.slices_per_group
= n
;
159 dfc
->fcp
.init_fec
= dccp_init_fec
;
160 dfc
->fcp
.send_fec
= dccp_send_fec
;
161 dfc
->fcp
.need_periodic_header
= false;
162 dfc
->fc
= vss_add_fec_client(sc
, &dfc
->fcp
);
165 static int dccp_com_on(__a_unused
struct sender_command_data
*scd
)
167 generic_com_on(dss
, IPPROTO_DCCP
);
171 static int dccp_com_off(__a_unused
struct sender_command_data
*scd
)
173 dccp_shutdown_clients();
174 generic_com_off(dss
);
179 static int dccp_com_deny(struct sender_command_data
*scd
)
181 generic_com_deny(scd
, dss
);
185 static int dccp_com_allow(struct sender_command_data
*scd
)
187 generic_com_allow(scd
, dss
);
192 * Return list of available CCIDs or warning, in static buffer.
194 static const char *dccp_list_available_ccids(void)
196 /* Worst case length: n * 3 digits + n-1 spaces + '\0' */
197 static char list
[DCCP_MAX_HOST_CCIDS
* 4];
201 nccids
= dccp_available_ccids(&ccids
);
203 snprintf(list
, sizeof(list
), "Unable to query available CCIDs");
205 for (i
= len
= 0; i
< nccids
; i
++)
206 len
+= snprintf(list
+ len
, sizeof(list
) - len
,
207 "%s%d", i
? " " : "", ccids
[i
]);
212 static char *dccp_status(void)
214 char *status
= generic_sender_status(dss
, "dccp");
215 char *result
= make_message("%ssupported ccids: %s\n", status
,
216 dccp_list_available_ccids());
222 * Initialize the client list and the access control list and listen on the
225 static void dccp_send_init(void)
227 init_sender_status(dss
, OPT_RESULT(DCCP_ACCESS
),
228 OPT_UINT32_VAL(DCCP_PORT
), OPT_UINT32_VAL(DCCP_MAX_CLIENTS
),
229 OPT_GIVEN(DCCP_DEFAULT_DENY
));
230 generic_com_on(dss
, IPPROTO_DCCP
);
236 * This sender offers congestion control not available in plain TCP. Most
237 * methods of the sender structure are implemented as simple wrappers for the
238 * generic functions defined in \ref send_common.c. Like UDP streams, DCCP
239 * streams are sent FEC-encoded.
241 const struct sender dccp_sender
= {
243 .init
= dccp_send_init
,
244 .shutdown
= dccp_shutdown
,
245 .pre_select
= dccp_pre_select
,
246 .post_select
= dccp_post_select
,
247 .shutdown_clients
= dccp_shutdown_clients
,
249 [SENDER_on
] = dccp_com_on
,
250 [SENDER_off
] = dccp_com_off
,
251 [SENDER_deny
] = dccp_com_deny
,
252 [SENDER_allow
] = dccp_com_allow
,
254 .help
= generic_sender_help
,
255 .status
= dccp_status
,