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);
}
