aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorChristian Grothoff <christian@grothoff.org>2012-09-17 13:18:08 +0000
committerChristian Grothoff <christian@grothoff.org>2012-09-17 13:18:08 +0000
commita30cdd84fc97a0a78461eb8d4d5702a5f8178221 (patch)
tree3c70805a135b0475e3c72d0ebf93b91d954cf4ed /src
parent31a9f6b88363ed234a01dd521e7bd1342071b486 (diff)
downloadgnunet-a30cdd84fc97a0a78461eb8d4d5702a5f8178221.tar.gz
gnunet-a30cdd84fc97a0a78461eb8d4d5702a5f8178221.zip
fixing udp busyloop reported by LRN on #gnunet on 8-27
Diffstat (limited to 'src')
-rw-r--r--src/transport/plugin_transport_udp.c372
-rw-r--r--src/transport/plugin_transport_udp.h4
2 files changed, 146 insertions, 230 deletions
diff --git a/src/transport/plugin_transport_udp.c b/src/transport/plugin_transport_udp.c
index ae135a468..f133dd749 100644
--- a/src/transport/plugin_transport_udp.c
+++ b/src/transport/plugin_transport_udp.c
@@ -348,6 +348,51 @@ static void
348stop_session_timeout (struct Session *s); 348stop_session_timeout (struct Session *s);
349 349
350 350
351/**
352 * (re)schedule select tasks for this plugin.
353 *
354 * @param plugin plugin to reschedule
355 */
356static void
357schedule_select (struct Plugin *plugin)
358{
359 struct GNUNET_TIME_Relative min_delay;
360 struct UDPMessageWrapper *udpw;
361
362 if (NULL != plugin->sockv4)
363 {
364 min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
365 for (udpw = plugin->ipv4_queue_head; NULL != udpw; udpw = udpw->next)
366 min_delay = GNUNET_TIME_relative_min (min_delay,
367 GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer));
368
369 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
370 GNUNET_SCHEDULER_cancel(plugin->select_task);
371 plugin->select_task =
372 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
373 (0 == min_delay.rel_value) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
374 plugin->rs_v4,
375 (0 == min_delay.rel_value) ? plugin->ws_v4 : NULL,
376 &udp_plugin_select, plugin);
377 }
378 if (NULL != plugin->sockv6)
379 {
380 min_delay = GNUNET_TIME_UNIT_FOREVER_REL;
381 for (udpw = plugin->ipv6_queue_head; NULL != udpw; udpw = udpw->next)
382 min_delay = GNUNET_TIME_relative_min (min_delay,
383 GNUNET_TIME_absolute_get_remaining (udpw->session->flow_delay_from_other_peer));
384
385 if (GNUNET_SCHEDULER_NO_TASK != plugin->select_task_v6)
386 GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
387 plugin->select_task_v6 =
388 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
389 (0 == min_delay.rel_value) ? GNUNET_TIME_UNIT_FOREVER_REL : min_delay,
390 plugin->rs_v6,
391 (0 == min_delay.rel_value) ? plugin->ws_v6 : NULL,
392 &udp_plugin_select_v6, plugin);
393 }
394}
395
351 396
352/** 397/**
353 * Function called for a quick conversion of the binary address to 398 * Function called for a quick conversion of the binary address to
@@ -792,6 +837,79 @@ udp_disconnect (void *cls, const struct GNUNET_PeerIdentity *target)
792} 837}
793 838
794 839
840/**
841 * Session was idle, so disconnect it
842 */
843static void
844session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
845{
846 GNUNET_assert (NULL != cls);
847 struct Session *s = cls;
848
849 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
850 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
851 "Session %p was idle for %llu ms, disconnecting\n",
852 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
853 /* call session destroy function */
854 disconnect_session (s);
855}
856
857
858/**
859 * Start session timeout
860 */
861static void
862start_session_timeout (struct Session *s)
863{
864 GNUNET_assert (NULL != s);
865 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == s->timeout_task);
866 s->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
867 &session_timeout,
868 s);
869 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
870 "Timeout for session %p set to %llu ms\n",
871 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
872}
873
874
875/**
876 * Increment session timeout due to activity
877 */
878static void
879reschedule_session_timeout (struct Session *s)
880{
881 GNUNET_assert (NULL != s);
882 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
883
884 GNUNET_SCHEDULER_cancel (s->timeout_task);
885 s->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
886 &session_timeout,
887 s);
888 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
889 "Timeout rescheduled for session %p set to %llu ms\n",
890 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
891}
892
893
894/**
895 * Cancel timeout
896 */
897static void
898stop_session_timeout (struct Session *s)
899{
900 GNUNET_assert (NULL != s);
901
902 if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
903 {
904 GNUNET_SCHEDULER_cancel (s->timeout_task);
905 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
906 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
907 "Timeout stopped for session %p canceled\n",
908 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
909 }
910}
911
912
795static struct Session * 913static struct Session *
796create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target, 914create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
797 const void *addr, size_t addrlen, 915 const void *addr, size_t addrlen,
@@ -850,7 +968,7 @@ create_session (struct Plugin *plugin, const struct GNUNET_PeerIdentity *target,
850 s->target = *target; 968 s->target = *target;
851 s->sock_addr = (const struct sockaddr *) &s[1]; 969 s->sock_addr = (const struct sockaddr *) &s[1];
852 s->last_expected_delay = GNUNET_TIME_UNIT_SECONDS; 970 s->last_expected_delay = GNUNET_TIME_UNIT_SECONDS;
853 start_session_timeout(s); 971 start_session_timeout (s);
854 return s; 972 return s;
855} 973}
856 974
@@ -1033,14 +1151,12 @@ enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
1033 struct FragmentationContext *frag_ctx = cls; 1151 struct FragmentationContext *frag_ctx = cls;
1034 struct Plugin *plugin = frag_ctx->plugin; 1152 struct Plugin *plugin = frag_ctx->plugin;
1035 struct UDPMessageWrapper * udpw; 1153 struct UDPMessageWrapper * udpw;
1036 struct Session *s;
1037 size_t msg_len = ntohs (msg->size); 1154 size_t msg_len = ntohs (msg->size);
1038 1155
1039 LOG (GNUNET_ERROR_TYPE_DEBUG, 1156 LOG (GNUNET_ERROR_TYPE_DEBUG,
1040 "Enqueuing fragment with %u bytes %u\n", msg_len , sizeof (struct UDPMessageWrapper)); 1157 "Enqueuing fragment with %u bytes %u\n", msg_len , sizeof (struct UDPMessageWrapper));
1041 udpw = GNUNET_malloc (sizeof (struct UDPMessageWrapper) + msg_len); 1158 udpw = GNUNET_malloc (sizeof (struct UDPMessageWrapper) + msg_len);
1042 udpw->session = frag_ctx->session; 1159 udpw->session = frag_ctx->session;
1043 s = udpw->session;
1044 udpw->udp = (char *) &udpw[1]; 1160 udpw->udp = (char *) &udpw[1];
1045 1161
1046 udpw->msg_size = msg_len; 1162 udpw->msg_size = msg_len;
@@ -1050,39 +1166,7 @@ enqueue_fragment (void *cls, const struct GNUNET_MessageHeader *msg)
1050 udpw->frag_ctx = frag_ctx; 1166 udpw->frag_ctx = frag_ctx;
1051 memcpy (udpw->udp, msg, msg_len); 1167 memcpy (udpw->udp, msg, msg_len);
1052 enqueue (plugin, udpw); 1168 enqueue (plugin, udpw);
1053 1169 schedule_select (plugin);
1054 if (s->addrlen == sizeof (struct sockaddr_in))
1055 {
1056 if (plugin->with_v4_ws == GNUNET_NO)
1057 {
1058 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
1059 GNUNET_SCHEDULER_cancel(plugin->select_task);
1060
1061 plugin->select_task =
1062 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1063 GNUNET_TIME_UNIT_FOREVER_REL,
1064 plugin->rs_v4,
1065 plugin->ws_v4,
1066 &udp_plugin_select, plugin);
1067 plugin->with_v4_ws = GNUNET_YES;
1068 }
1069 }
1070 else if (s->addrlen == sizeof (struct sockaddr_in6))
1071 {
1072 if (plugin->with_v6_ws == GNUNET_NO)
1073 {
1074 if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK)
1075 GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
1076
1077 plugin->select_task_v6 =
1078 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1079 GNUNET_TIME_UNIT_FOREVER_REL,
1080 plugin->rs_v6,
1081 plugin->ws_v6,
1082 &udp_plugin_select_v6, plugin);
1083 plugin->with_v6_ws = GNUNET_YES;
1084 }
1085 }
1086} 1170}
1087 1171
1088 1172
@@ -1169,13 +1253,12 @@ udp_plugin_send (void *cls,
1169 udpw->frag_ctx = NULL; 1253 udpw->frag_ctx = NULL;
1170 memcpy (udpw->udp, udp, sizeof (struct UDPMessage)); 1254 memcpy (udpw->udp, udp, sizeof (struct UDPMessage));
1171 memcpy (&udpw->udp[sizeof (struct UDPMessage)], msgbuf, msgbuf_size); 1255 memcpy (&udpw->udp[sizeof (struct UDPMessage)], msgbuf, msgbuf_size);
1172
1173 enqueue (plugin, udpw); 1256 enqueue (plugin, udpw);
1174 } 1257 }
1175 else 1258 else
1176 { 1259 {
1177 LOG (GNUNET_ERROR_TYPE_DEBUG, 1260 LOG (GNUNET_ERROR_TYPE_DEBUG,
1178 "UDP has to fragment message \n"); 1261 "UDP has to fragment message\n");
1179 if (s->frag_ctx != NULL) 1262 if (s->frag_ctx != NULL)
1180 return GNUNET_SYSERR; 1263 return GNUNET_SYSERR;
1181 memcpy (&udp[1], msgbuf, msgbuf_size); 1264 memcpy (&udp[1], msgbuf, msgbuf_size);
@@ -1197,40 +1280,7 @@ udp_plugin_send (void *cls,
1197 1280
1198 s->frag_ctx = frag_ctx; 1281 s->frag_ctx = frag_ctx;
1199 } 1282 }
1200 1283 schedule_select (plugin);
1201 if (s->addrlen == sizeof (struct sockaddr_in))
1202 {
1203 if (plugin->with_v4_ws == GNUNET_NO)
1204 {
1205 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
1206 GNUNET_SCHEDULER_cancel(plugin->select_task);
1207
1208 plugin->select_task =
1209 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1210 GNUNET_TIME_UNIT_FOREVER_REL,
1211 plugin->rs_v4,
1212 plugin->ws_v4,
1213 &udp_plugin_select, plugin);
1214 plugin->with_v4_ws = GNUNET_YES;
1215 }
1216 }
1217 else if (s->addrlen == sizeof (struct sockaddr_in6))
1218 {
1219 if (plugin->with_v6_ws == GNUNET_NO)
1220 {
1221 if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK)
1222 GNUNET_SCHEDULER_cancel(plugin->select_task_v6);
1223
1224 plugin->select_task_v6 =
1225 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1226 GNUNET_TIME_UNIT_FOREVER_REL,
1227 plugin->rs_v6,
1228 plugin->ws_v6,
1229 &udp_plugin_select_v6, plugin);
1230 plugin->with_v6_ws = GNUNET_YES;
1231 }
1232 }
1233
1234 return mlen; 1284 return mlen;
1235} 1285}
1236 1286
@@ -1964,38 +2014,18 @@ udp_plugin_select (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
1964 struct Plugin *plugin = cls; 2014 struct Plugin *plugin = cls;
1965 2015
1966 plugin->select_task = GNUNET_SCHEDULER_NO_TASK; 2016 plugin->select_task = GNUNET_SCHEDULER_NO_TASK;
1967 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) 2017 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
1968 return; 2018 return;
1969 plugin->with_v4_ws = GNUNET_NO; 2019 if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_READ_READY)) &&
1970 2020 (NULL != plugin->sockv4) &&
1971 if ((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0) 2021 (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4)) )
1972 { 2022 udp_select_read (plugin, plugin->sockv4);
1973 if ((NULL != plugin->sockv4) && 2023 if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
1974 (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv4))) 2024 (NULL != plugin->sockv4) &&
1975 udp_select_read (plugin, plugin->sockv4); 2025 (NULL != plugin->ipv4_queue_head) &&
1976 2026 (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv4)) )
1977 } 2027 udp_select_send (plugin, plugin->sockv4);
1978 2028 schedule_select (plugin);
1979 if ((tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0)
1980 {
1981 if ((NULL != plugin->sockv4) && (plugin->ipv4_queue_head != NULL) &&
1982 (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv4)))
1983 {
1984 udp_select_send (plugin, plugin->sockv4);
1985 }
1986 }
1987
1988 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
1989 GNUNET_SCHEDULER_cancel (plugin->select_task);
1990 plugin->select_task = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
1991 GNUNET_TIME_UNIT_FOREVER_REL,
1992 plugin->rs_v4,
1993 (plugin->ipv4_queue_head != NULL) ? plugin->ws_v4 : NULL,
1994 &udp_plugin_select, plugin);
1995 if (plugin->ipv4_queue_head != NULL)
1996 plugin->with_v4_ws = GNUNET_YES;
1997 else
1998 plugin->with_v4_ws = GNUNET_NO;
1999} 2029}
2000 2030
2001 2031
@@ -2013,36 +2043,17 @@ udp_plugin_select_v6 (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2013 struct Plugin *plugin = cls; 2043 struct Plugin *plugin = cls;
2014 2044
2015 plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK; 2045 plugin->select_task_v6 = GNUNET_SCHEDULER_NO_TASK;
2016 if ((tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN) != 0) 2046 if (0 != (tc->reason & GNUNET_SCHEDULER_REASON_SHUTDOWN))
2017 return; 2047 return;
2018 2048 if ( ((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0) &&
2019 plugin->with_v6_ws = GNUNET_NO; 2049 (NULL != plugin->sockv6) &&
2020 if ((tc->reason & GNUNET_SCHEDULER_REASON_READ_READY) != 0) 2050 (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6)) )
2021 { 2051 udp_select_read (plugin, plugin->sockv6);
2022 if ((NULL != plugin->sockv6) && 2052 if ( (0 != (tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY)) &&
2023 (GNUNET_NETWORK_fdset_isset (tc->read_ready, plugin->sockv6))) 2053 (NULL != plugin->sockv6) && (plugin->ipv6_queue_head != NULL) &&
2024 udp_select_read (plugin, plugin->sockv6); 2054 (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv6)) )
2025 } 2055 udp_select_send (plugin, plugin->sockv6);
2026 2056 schedule_select (plugin);
2027 if ((tc->reason & GNUNET_SCHEDULER_REASON_WRITE_READY) != 0)
2028 {
2029 if ((NULL != plugin->sockv6) && (plugin->ipv6_queue_head != NULL) &&
2030 (GNUNET_NETWORK_fdset_isset (tc->write_ready, plugin->sockv6)))
2031 {
2032 udp_select_send (plugin, plugin->sockv6);
2033 }
2034 }
2035 if (plugin->select_task_v6 != GNUNET_SCHEDULER_NO_TASK)
2036 GNUNET_SCHEDULER_cancel (plugin->select_task_v6);
2037 plugin->select_task_v6 = GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
2038 GNUNET_TIME_UNIT_FOREVER_REL,
2039 plugin->rs_v6,
2040 (plugin->ipv6_queue_head != NULL) ? plugin->ws_v6 : NULL,
2041 &udp_plugin_select_v6, plugin);
2042 if (plugin->ipv6_queue_head != NULL)
2043 plugin->with_v6_ws = GNUNET_YES;
2044 else
2045 plugin->with_v6_ws = GNUNET_NO;
2046} 2057}
2047 2058
2048 2059
@@ -2158,17 +2169,8 @@ setup_sockets (struct Plugin *plugin, struct sockaddr_in6 *serverAddrv6, struct
2158 GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4); 2169 GNUNET_NETWORK_fdset_set (plugin->ws_v4, plugin->sockv4);
2159 } 2170 }
2160 2171
2161 if (sockets_created == 0) 2172 if (0 == sockets_created)
2162 LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n")); 2173 LOG (GNUNET_ERROR_TYPE_WARNING, _("Failed to open UDP sockets\n"));
2163
2164 plugin->select_task =
2165 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
2166 GNUNET_TIME_UNIT_FOREVER_REL,
2167 plugin->rs_v4,
2168 NULL,
2169 &udp_plugin_select, plugin);
2170 plugin->with_v4_ws = GNUNET_NO;
2171
2172 if (plugin->enable_ipv6 == GNUNET_YES) 2174 if (plugin->enable_ipv6 == GNUNET_YES)
2173 { 2175 {
2174 plugin->rs_v6 = GNUNET_NETWORK_fdset_create (); 2176 plugin->rs_v6 = GNUNET_NETWORK_fdset_create ();
@@ -2180,16 +2182,8 @@ setup_sockets (struct Plugin *plugin, struct sockaddr_in6 *serverAddrv6, struct
2180 GNUNET_NETWORK_fdset_set (plugin->rs_v6, plugin->sockv6); 2182 GNUNET_NETWORK_fdset_set (plugin->rs_v6, plugin->sockv6);
2181 GNUNET_NETWORK_fdset_set (plugin->ws_v6, plugin->sockv6); 2183 GNUNET_NETWORK_fdset_set (plugin->ws_v6, plugin->sockv6);
2182 } 2184 }
2183
2184 plugin->select_task_v6 =
2185 GNUNET_SCHEDULER_add_select (GNUNET_SCHEDULER_PRIORITY_DEFAULT,
2186 GNUNET_TIME_UNIT_FOREVER_REL,
2187 plugin->rs_v6,
2188 NULL,
2189 &udp_plugin_select_v6, plugin);
2190 plugin->with_v6_ws = GNUNET_NO;
2191 } 2185 }
2192 2186 schedule_select (plugin);
2193 plugin->nat = GNUNET_NAT_register (plugin->env->cfg, 2187 plugin->nat = GNUNET_NAT_register (plugin->env->cfg,
2194 GNUNET_NO, plugin->port, 2188 GNUNET_NO, plugin->port,
2195 sockets_created, 2189 sockets_created,
@@ -2199,79 +2193,6 @@ setup_sockets (struct Plugin *plugin, struct sockaddr_in6 *serverAddrv6, struct
2199 return sockets_created; 2193 return sockets_created;
2200} 2194}
2201 2195
2202/**
2203 * Session was idle, so disconnect it
2204 */
2205static void
2206session_timeout (void *cls, const struct GNUNET_SCHEDULER_TaskContext *tc)
2207{
2208 GNUNET_assert (NULL != cls);
2209 struct Session *s = cls;
2210
2211 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2212 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2213 "Session %p was idle for %llu ms, disconnecting\n",
2214 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
2215 /* call session destroy function */
2216 disconnect_session(s);
2217}
2218
2219
2220/**
2221 * Start session timeout
2222 */
2223static void
2224start_session_timeout (struct Session *s)
2225{
2226 GNUNET_assert (NULL != s);
2227 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK == s->timeout_task);
2228 s->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2229 &session_timeout,
2230 s);
2231 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2232 "Timeout for session %p set to %llu ms\n",
2233 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
2234}
2235
2236
2237/**
2238 * Increment session timeout due to activity
2239 */
2240static void
2241reschedule_session_timeout (struct Session *s)
2242{
2243 GNUNET_assert (NULL != s);
2244 GNUNET_assert (GNUNET_SCHEDULER_NO_TASK != s->timeout_task);
2245
2246 GNUNET_SCHEDULER_cancel (s->timeout_task);
2247 s->timeout_task = GNUNET_SCHEDULER_add_delayed (GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
2248 &session_timeout,
2249 s);
2250 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2251 "Timeout rescheduled for session %p set to %llu ms\n",
2252 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
2253}
2254
2255
2256/**
2257 * Cancel timeout
2258 */
2259static void
2260stop_session_timeout (struct Session *s)
2261{
2262 GNUNET_assert (NULL != s);
2263
2264 if (GNUNET_SCHEDULER_NO_TASK != s->timeout_task)
2265 {
2266 GNUNET_SCHEDULER_cancel (s->timeout_task);
2267 s->timeout_task = GNUNET_SCHEDULER_NO_TASK;
2268 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
2269 "Timeout stopped for session %p canceled\n",
2270 s, (unsigned long long) GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT.rel_value);
2271 }
2272}
2273
2274
2275 2196
2276/** 2197/**
2277 * The exported method. Makes the core api available via a global and 2198 * The exported method. Makes the core api available via a global and
@@ -2488,7 +2409,6 @@ libgnunet_plugin_transport_udp_done (void *cls)
2488 } 2409 }
2489 2410
2490 stop_broadcast (plugin); 2411 stop_broadcast (plugin);
2491
2492 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK) 2412 if (plugin->select_task != GNUNET_SCHEDULER_NO_TASK)
2493 { 2413 {
2494 GNUNET_SCHEDULER_cancel (plugin->select_task); 2414 GNUNET_SCHEDULER_cancel (plugin->select_task);
diff --git a/src/transport/plugin_transport_udp.h b/src/transport/plugin_transport_udp.h
index 5637524bc..52c3e64bf 100644
--- a/src/transport/plugin_transport_udp.h
+++ b/src/transport/plugin_transport_udp.h
@@ -175,8 +175,6 @@ struct Plugin
175 struct GNUNET_NETWORK_FDSet *ws_v4; 175 struct GNUNET_NETWORK_FDSet *ws_v4;
176 176
177 177
178 int with_v4_ws;
179
180 /** 178 /**
181 * The read socket for IPv4 179 * The read socket for IPv4
182 */ 180 */
@@ -193,8 +191,6 @@ struct Plugin
193 */ 191 */
194 struct GNUNET_NETWORK_FDSet *ws_v6; 192 struct GNUNET_NETWORK_FDSet *ws_v6;
195 193
196 int with_v6_ws;
197
198 /** 194 /**
199 * The read socket for IPv6 195 * The read socket for IPv6
200 */ 196 */