static void open_socket_out_connected(struct tevent_req *subreq) { struct tevent_req *req = tevent_req_callback_data(subreq, struct tevent_req); struct open_socket_out_state *state = tevent_req_data(req, struct open_socket_out_state); int ret; int sys_errno; ret = async_connect_recv(subreq, &sys_errno); TALLOC_FREE(subreq); if (ret == 0) { tevent_req_done(req); return; } if ( #ifdef ETIMEDOUT (sys_errno == ETIMEDOUT) || #endif (sys_errno == EINPROGRESS) || (sys_errno == EALREADY) || (sys_errno == EAGAIN)) { /* * retry */ if (state->wait_usec < 250000) { state->wait_usec *= 1.5; } subreq = async_connect_send(state, state->ev, state->fd, (struct sockaddr *)&state->ss, state->salen); if (tevent_req_nomem(subreq, req)) { return; } if (!tevent_req_set_endtime( subreq, state->ev, timeval_current_ofs_usec(state->wait_usec))) { tevent_req_nterror(req, NT_STATUS_NO_MEMORY); return; } tevent_req_set_callback(subreq, open_socket_out_connected, req); return; } #ifdef EISCONN if (sys_errno == EISCONN) { tevent_req_done(req); return; } #endif /* real error */ tevent_req_nterror(req, map_nt_error_from_unix(sys_errno)); }
static void idle_handler(struct tevent_context *ev, struct tevent_timer *te, struct timeval t, void *private_data) { struct smb2_transport *transport = talloc_get_type(private_data, struct smb2_transport); struct timeval next; transport->idle.func(transport, transport->idle.private_data); next = timeval_current_ofs_usec(transport->idle.period); transport->idle.te = tevent_add_timer(transport->ev, transport, next, idle_handler, transport); }
/* setup the idle handler for a transport the period is in microseconds */ void smb2_transport_idle_handler(struct smb2_transport *transport, void (*idle_func)(struct smb2_transport *, void *), uint64_t period, void *private_data) { TALLOC_FREE(transport->idle.te); transport->idle.func = idle_func; transport->idle.private_data = private_data; transport->idle.period = period; transport->idle.te = tevent_add_timer(transport->ev, transport, timeval_current_ofs_usec(period), idle_handler, transport); }
void trigger_write_time_update(struct files_struct *fsp) { int delay; if (fsp->posix_open) { /* Don't use delayed writes on POSIX files. */ return; } if (fsp->write_time_forced) { /* No point - "sticky" write times * in effect. */ return; } /* We need to remember someone did a write * and update to current time on close. */ fsp->update_write_time_on_close = true; if (fsp->update_write_time_triggered) { /* * We only update the write time after 2 seconds * on the first normal write. After that * no other writes affect this until close. */ return; } fsp->update_write_time_triggered = true; delay = lp_parm_int(SNUM(fsp->conn), "smbd", "writetimeupdatedelay", WRITE_TIME_UPDATE_USEC_DELAY); DEBUG(5, ("Update write time %d usec later on %s\n", delay, fsp_str_dbg(fsp))); /* trigger the update 2 seconds later */ fsp->update_write_time_event = tevent_add_timer(fsp->conn->sconn->ev_ctx, NULL, timeval_current_ofs_usec(delay), update_write_time_handler, fsp); }