void connection::begin_timeout(unsigned int in_seconds) { cancel_timeout(); tt_.expires_from_now(boost::posix_time::seconds(in_seconds)); tt_.async_wait( boost::bind( &connection::do_timeout, shared_from_this(), _1 )); }
static void request_begin(void) { if (active_requests++ == 0) { /* First request, cancel timer. */ cancel_timeout(); } }
void handle_deinit(void) { hide_mainwin(); if (g_device_id_list != NULL) { free(g_device_id_list); g_device_id_list = NULL; } cancel_timeout(); cancel_status_check(); if (inactivity_timer != NULL) app_timer_cancel(inactivity_timer); }
// Callback for when user switches between devices void device_switched() { reset_inactivity_timer(); cancel_status_check(); cancel_timeout(); if (status_fetch_delay_timer != NULL) { app_timer_cancel(status_fetch_delay_timer); status_fetch_delay_timer = NULL; } // Fetch device details after a brief delay to avoid busy comms error if (details_fetch_delay_timer == NULL) details_fetch_delay_timer = app_timer_register(500, device_details_fetch_delayed, NULL); else app_timer_reschedule(details_fetch_delay_timer, 500); }
void lease_pinged(struct iaddr from, u_int8_t *packet, int length) { struct lease *lp; /* * Don't try to look up a pinged lease if we aren't trying to * ping one - otherwise somebody could easily make us churn by * just forging repeated ICMP EchoReply packets for us to look * up. */ if (!outstanding_pings) return; lp = find_lease_by_ip_addr(from); if (!lp) { note("unexpected ICMP Echo Reply from %s", piaddr(from)); return; } if (!lp->state && !lp->releasing) { warning("ICMP Echo Reply for %s arrived late or is spurious.", piaddr(from)); return; } /* At this point it looks like we pinged a lease and got a * response, which shouldn't have happened. * if it did it's either one of two two cases: * 1 - we pinged this lease before offering it and * something answered, so we abandon it. * 2 - we pinged this lease before releasing it * and something answered, so we don't release it. */ if (lp->releasing) { warning("IP address %s answers a ping after sending a release", piaddr(lp->ip_addr)); warning("Possible release spoof - Not releasing address %s", piaddr(lp->ip_addr)); lp->releasing = 0; } else { free_lease_state(lp->state, "lease_pinged"); lp->state = NULL; abandon_lease(lp, "pinged before offer"); } cancel_timeout(lease_ping_timeout, lp); --outstanding_pings; }
// Callback to show any error received from the phone JS or MyQ servers void comms_error(char *error_message) { cancel_status_check(); cancel_timeout(); show_msg(error_message, false, 0); if (g_device_count == 0) { if (inactivity_timer != NULL) { app_timer_cancel(inactivity_timer); inactivity_timer = NULL; } // If there are no devices, hide main win so the app closes when the error message is closed hide_mainwin(); } else { reset_inactivity_timer(); } }
static void gcin_display_closed (GdkDisplay *display, gboolean is_error, GtkIMContextGCIN *context_xim) { #if DBG puts("gcin_display_closed"); #endif #if NEW_GTK_IM cancel_timeout(context_xim); #endif if (!context_xim->gcin_ch) return; gcin_im_client_close(context_xim->gcin_ch); context_xim->gcin_ch = NULL; }
static void CancelTimeout(int *t) { unsigned long ps = 0; int v; #ifdef EMULATE_LYNXOS_ON_LINUX ps = 0; #endif disable(ps); { if ((v = *t)) { *t = 0; cancel_timeout(v); } } restore(ps); }
// Callbck for when the device status has been fetched void device_status_fetched(int device_id, DeviceStatus status, char *status_changed) { APP_LOG(APP_LOG_LEVEL_DEBUG, "Status fetched - ID: %d, Status: %d, Selected ID: %d", device_id, status, g_device_id_list[g_device_selected]); reset_inactivity_timer(); if (g_device_id_list[g_device_selected] == device_id) { if (s_device_status_target != DSNone) { // If expecting the device status to change (e.g. Garage door opening/closing) cancel_status_check(); if (((status == DSVGDOOpen) ? DSOnOpen : status) != s_device_status_target) { APP_LOG(APP_LOG_LEVEL_DEBUG, "Status still not reached target, checking again in 2 seconds..."); // Still not reached target status, so check again after 2 seconds status_change_check_timer = app_timer_register(2000, status_change_check, NULL); } else { APP_LOG(APP_LOG_LEVEL_DEBUG, "Status has reached target"); // Status changed, so stop checking cancel_timeout(); s_device_status_target = DSNone; s_device_status = status; strncpy(s_status_changed, status_changed, sizeof(s_status_changed)); s_status_changed[sizeof(s_status_changed)-1] = '\0'; show_device_status(status, status_changed); light_enable_interaction(); vibes_short_pulse(); } } else { // Not expecting status to change, so just update the display cancel_status_check(); if (status != s_device_status) { s_device_status = status; light_enable_interaction(); } strncpy(s_status_changed, status_changed, sizeof(s_status_changed)); s_status_changed[sizeof(s_status_changed)-1] = '\0'; show_device_status(status, status_changed); } } }
void connection::on_body_read( const boost::system::error_code& error, std::size_t bytes_transferred) { if (error) { return stop(); } cancel_timeout(); bufsz_ += bytes_transferred; inbound_.append_body(bodybuf_.data(), bodybuf_.data() + bytes_transferred); // handler_.handle_chunk(string_t(bodybuf_.data())); // if we read enough bytes as specified in the Content-Length header, process body if (bufsz_ >= inbound_.content_length) { return on_request_read(); } return read_body(); }
void connection::stop() { cancel_timeout(); boost::system::error_code ignored_ec; // initiate graceful connection closure & stop all asynchronous ops try { socket_.cancel(); socket_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec); socket_.close(ignored_ec); } catch (std::exception& e) { error() << "bad socket; couldn't close cleanly"; } longevity_timer_.stop(); debug() << "closed (elapsed: " << longevity_timer_.elapsed << "ms)"; if (close_handler_) { close_handler_(shared_from_this()); } }
static void cancel_lpe(int s) { if (sockets[s].lpevent>=0) { cancel_timeout(sockets[s].lpevent); sockets[s].lpevent=-1; } }
void connection::on_header_read(const boost::system::error_code& e, std::size_t bytes_transferred) { if (e) { return stop(); } cancel_timeout(); boost::tribool result; std::string trailer; // debug() << "received " << bytes_transferred << " bytes"; result = parser_.parse_header(headbuf_.data(), headbuf_.data() + bytes_transferred, trailer); // parser failed processing the header for some reason if (!result) { debug() << "invalid request header, rejecting"; return reject(reply::bad_request); } // header is incomplete, need more feed else if (result == boost::indeterminate) { return read_header(); } // header was successfully parsed, now let's validate it if (!inbound_.validate()) { reply::status_type t; // track the error switch(inbound_.status) { case request::status_t::invalid_method: error() << "request has a non-supported method '" << inbound_ << "', aborting"; t = reply::not_implemented; break; case request::status_t::invalid_format: error() << "request has a non-supported format '" << inbound_.format_str << "', aborting"; t = reply::not_implemented; break; case request::status_t::missing_length: info() << "request does not specify a Content-Length, can not attempt indeterminate body reading, aborting"; t = reply::bad_request; break; case request::status_t::invalid_length: error() << "request has 0 Content-Length, aborting"; t = reply::bad_request; break; default: error() << "unknown request status: " << (int)inbound_.status << ", investigate!"; t = reply::internal_server_error; } return reject(t); } // set up the UUID logging // __set_uuid(inbound_.uuid); handler_.init(); // process any trailing bytes that were not part of the HTTP header size_t trailing_bytes = trailer.size(); if (trailing_bytes > 0) { std::istringstream buf(trailer); buf.read(bodybuf_.data(), trailing_bytes); debug() << "there are " << trailing_bytes << "bytes of trailing data" << " and req clength is " << inbound_.content_length << "b"; inbound_.append_body(bodybuf_.data(), bodybuf_.data() + trailer.size()); // did the trailer contain the whole request body? if (trailer.size() == inbound_.content_length) return on_request_read(); bufsz_ += trailing_bytes; } reading_timer_.start(); return read_body(); }
/* * Loop waiting for packets, timeouts or routing messages. */ void dispatch(void) { int count, to_msec; struct pollfd fds[3]; time_t cur_time, howlong; void (*func)(void); while (quit == 0) { /* * Call expired timeout, and then if there's still * a timeout registered, time out the select call then. */ another: if (!ifi) { warning("No interfaces available"); quit = INTERNALSIG; continue; } if (ifi->rdomain != get_rdomain(ifi->name)) { warning("Interface %s:" " rdomain changed out from under us", ifi->name); quit = INTERNALSIG; continue; } if (timeout.func) { time(&cur_time); if (timeout.when <= cur_time) { func = timeout.func; cancel_timeout(); (*(func))(); goto another; } /* * Figure timeout in milliseconds, and check for * potential overflow, so we can cram into an * int for poll, while not polling with a * negative timeout and blocking indefinitely. */ howlong = timeout.when - cur_time; if (howlong > INT_MAX / 1000) howlong = INT_MAX / 1000; to_msec = howlong * 1000; } else to_msec = -1; /* Set up the descriptors to be polled. */ if (!ifi || ifi->rfdesc == -1) { warning("No live interface to poll on"); quit = INTERNALSIG; continue; } fds[0].fd = ifi->rfdesc; fds[1].fd = routefd; /* Could be -1, which will be ignored. */ fds[2].fd = unpriv_ibuf->fd; fds[0].events = fds[1].events = fds[2].events = POLLIN; if (unpriv_ibuf->w.queued) fds[2].events |= POLLOUT; /* Wait for a packet or a timeout or unpriv_ibuf->fd. XXX */ count = poll(fds, 3, to_msec); /* Not likely to be transitory. */ if (count == -1) { if (errno == EAGAIN || errno == EINTR) { continue; } else { warning("poll: %s", strerror(errno)); quit = INTERNALSIG; continue; } } if ((fds[0].revents & (POLLIN | POLLHUP))) { if (ifi && ifi->linkstat && ifi->rfdesc != -1) got_one(); } if ((fds[1].revents & (POLLIN | POLLHUP))) { if (ifi) routehandler(); } if (fds[2].revents & POLLOUT) { if (msgbuf_write(&unpriv_ibuf->w) <= 0 && errno != EAGAIN) { warning("pipe write error to [priv]"); quit = INTERNALSIG; continue; } } if ((fds[2].revents & (POLLIN | POLLHUP))) { /* Pipe to [priv] closed. Assume it emitted error. */ quit = INTERNALSIG; continue; } } if (quit == SIGHUP) { /* Tell [priv] process that HUP has occurred. */ sendhup(client->active); warning("%s; restarting", strsignal(quit)); exit (0); } else if (quit != INTERNALSIG) { warning("%s; exiting", strsignal(quit)); exit(1); } }