/** pass time */
static void
time_passes(struct replay_runtime* runtime, struct replay_moment* mom)
{
struct fake_timer *t;
struct timeval tv = mom->elapse;
if(mom->string) {
char* xp = macro_process(runtime->vars, runtime, mom->string);
double sec;
if(!xp) fatal_exit("could not macro expand %s", mom->string);
verbose(VERB_ALGO, "EVAL %s", mom->string);
sec = atof(xp);
free(xp);
#ifndef S_SPLINT_S
tv.tv_sec = sec;
tv.tv_usec = (int)((sec - (double)tv.tv_sec) *1000000. + 0.5);
#endif
}
timeval_add(&runtime->now_tv, &tv);
runtime->now_secs = (time_t)runtime->now_tv.tv_sec;
#ifndef S_SPLINT_S
log_info("elapsed %d.%6.6d now %d.%6.6d",
(int)tv.tv_sec, (int)tv.tv_usec,
(int)runtime->now_tv.tv_sec, (int)runtime->now_tv.tv_usec);
#endif
/* see if any timers have fired; and run them */
while( (t=replay_get_oldest_timer(runtime)) ) {
t->enabled = 0;
log_info("fake_timer callback");
fptr_ok(fptr_whitelist_comm_timer(t->cb));
(*t->cb)(t->cb_arg);
}
}
static void clock(timer_event_t *tev) {
systime_t st = tv2st(tev->tev_when);
tev->tev_when = timeval_add(&tev->tev_when, &tick);
cpu_timer_add_event(tev);
callout_process(st);
sched_clock();
}
/*
* get_timeout
* returns the amount of time that select should block for before returning
* whether some packets have arrived or not
*/
static int get_timeout(struct timeval *tv)
{
struct timeval temp;
int64_t min_diff = 1000, temp_diff;
if(tv == NULL)
{
return 0;
}
bzero(&temp, sizeof(temp));
bzero(&tz, sizeof(tz));
if(gettimeofday(&temp, &tz) != 0)
{
printerror(errno, strerror, "could not gettimeofday");
return 0;
}
if(wait_between > 0)
{
temp_diff = timeval_diff_msec(&wait_between_tv, &temp);
if(temp_diff >= 0 && temp_diff < min_diff) min_diff = temp_diff;
}
tv->tv_sec = 0;
tv->tv_usec = 0;
timeval_add(tv, min_diff);
return 1;
}
void BroadcastReceiver::operator() (timeval *pTimeout) throw (FatalError)
{
// only one thread allowed per instance
if(0 == std::atomic_fetch_add(&mNumInstances, 1))
try {
size_t numRemotes = mIpTable.size();
timeval endTime, now;
gettimeofday(&endTime, NULL);
timeval_add(&endTime, pTimeout);
do
{
const Endpoint remote = GetNextRemote(pTimeout);
if(remote.IsValid()) {
numRemotes++;
}
gettimeofday(&now, NULL);
}
while(mIsRunning && timeval_sub(&endTime, &now, pTimeout));
} catch(FatalError& e) {
std::atomic_fetch_sub(&mNumInstances, 1);
throw(e);
}
std::atomic_fetch_sub(&mNumInstances, 1);
}
int main(void)
{
int *values = malloc(NUMVALUES * sizeof (*values));
unsigned long idx, sortnum;
struct timeval start, end, diff, tmp, runtime = {0,0};
assert(values != NULL);
for (sortnum = 0; sortnum < NUMSORTS; ++sortnum) {
for (idx = 0; idx < NUMVALUES; ++idx) {
values[idx] = rand();
}
(void) gettimeofday(&start, NULL);
//qsort(values, sizeof(*values), NUMVALUES, compare);
qsort(values, NUMVALUES, sizeof(*values), compare);
(void) gettimeofday(&end, NULL);
(void) timeval_subtract(&diff, &end, &start);
tmp = runtime;
(void) timeval_add(&runtime, &tmp, &diff);
/* printf("Runtime (hh:mm:ss:us)\t%02lu:%02lu:%02lu:%06lu\n",
runtime.tv_sec / 60LU / 60LU,
(runtime.tv_sec / 60LU) % 60LU,
runtime.tv_sec % 60LU,
runtime.tv_usec); */
}
printf("Runtime (hh:mm:ss:us)\t%02lu:%02lu:%02lu:%06lu\n",
runtime.tv_sec / 60LU / 60LU,
(runtime.tv_sec / 60LU) % 60LU,
runtime.tv_sec % 60LU,
runtime.tv_usec);
free(values);
return 0;
}
void comm_timer_set(struct comm_timer* timer, struct timeval* tv)
{
struct fake_timer* t = (struct fake_timer*)timer;
t->enabled = 1;
t->tv = *tv;
log_info("fake timer set %d.%6.6d",
(int)t->tv.tv_sec, (int)t->tv.tv_usec);
timeval_add(&t->tv, &t->runtime->now_tv);
}
struct timeval *elapse_time(struct timeval *tv, unsigned msec) {
assert(tv);
gettimeofday(tv, NULL);
if (msec)
timeval_add(tv, (Usec) msec*1000);
return tv;
}
void server_stats_add(struct stats_info* total, struct stats_info* a)
{
total->svr.num_queries += a->svr.num_queries;
total->svr.num_queries_missed_cache += a->svr.num_queries_missed_cache;
total->svr.num_queries_prefetch += a->svr.num_queries_prefetch;
total->svr.sum_query_list_size += a->svr.sum_query_list_size;
/* the max size reached is upped to higher of both */
if(a->svr.max_query_list_size > total->svr.max_query_list_size)
total->svr.max_query_list_size = a->svr.max_query_list_size;
if(a->svr.extended) {
int i;
total->svr.qtype_big += a->svr.qtype_big;
total->svr.qclass_big += a->svr.qclass_big;
total->svr.qtcp += a->svr.qtcp;
total->svr.qipv6 += a->svr.qipv6;
total->svr.qbit_QR += a->svr.qbit_QR;
total->svr.qbit_AA += a->svr.qbit_AA;
total->svr.qbit_TC += a->svr.qbit_TC;
total->svr.qbit_RD += a->svr.qbit_RD;
total->svr.qbit_RA += a->svr.qbit_RA;
total->svr.qbit_Z += a->svr.qbit_Z;
total->svr.qbit_AD += a->svr.qbit_AD;
total->svr.qbit_CD += a->svr.qbit_CD;
total->svr.qEDNS += a->svr.qEDNS;
total->svr.qEDNS_DO += a->svr.qEDNS_DO;
total->svr.ans_rcode_nodata += a->svr.ans_rcode_nodata;
total->svr.ans_secure += a->svr.ans_secure;
total->svr.ans_bogus += a->svr.ans_bogus;
total->svr.rrset_bogus += a->svr.rrset_bogus;
total->svr.unwanted_replies += a->svr.unwanted_replies;
total->svr.unwanted_queries += a->svr.unwanted_queries;
for(i=0; i<STATS_QTYPE_NUM; i++)
total->svr.qtype[i] += a->svr.qtype[i];
for(i=0; i<STATS_QCLASS_NUM; i++)
total->svr.qclass[i] += a->svr.qclass[i];
for(i=0; i<STATS_OPCODE_NUM; i++)
total->svr.qopcode[i] += a->svr.qopcode[i];
for(i=0; i<STATS_RCODE_NUM; i++)
total->svr.ans_rcode[i] += a->svr.ans_rcode[i];
for(i=0; i<NUM_BUCKETS_HIST; i++)
total->svr.hist[i] += a->svr.hist[i];
}
total->mesh_num_states += a->mesh_num_states;
total->mesh_num_reply_states += a->mesh_num_reply_states;
total->mesh_jostled += a->mesh_jostled;
total->mesh_dropped += a->mesh_dropped;
total->mesh_replies_sent += a->mesh_replies_sent;
timeval_add(&total->mesh_replies_sum_wait, &a->mesh_replies_sum_wait);
/* the medians are averaged together, this is not as accurate as
* taking the median over all of the data, but is good and fast
* added up here, division later*/
total->mesh_time_median += a->mesh_time_median;
}
/*
start a timer to refresh this name
*/
static void nbtd_wins_start_refresh_timer(struct nbtd_iface_name *iname)
{
uint32_t refresh_time;
uint32_t max_refresh_time = lp_parm_int(iname->iface->nbtsrv->task->lp_ctx, NULL, "nbtd", "max_refresh_time", 7200);
refresh_time = MIN(max_refresh_time, iname->ttl/2);
event_add_timed(iname->iface->nbtsrv->task->event_ctx,
iname,
timeval_add(&iname->registration_time, refresh_time, 0),
nbtd_wins_refresh, iname);
}
static void idle_handler(struct tevent_context *ev,
struct tevent_timer *te, struct timeval t, void *private_data)
{
struct smbcli_transport *transport = talloc_get_type(private_data,
struct smbcli_transport);
struct timeval next = timeval_add(&t, 0, transport->idle.period);
transport->socket->event.te = event_add_timed(transport->socket->event.ctx,
transport,
next,
idle_handler, transport);
transport->idle.func(transport, transport->idle.private_data);
}
void scavenger_schedule_disconnected(struct files_struct *fsp)
{
NTSTATUS status;
struct server_id self = messaging_server_id(fsp->conn->sconn->msg_ctx);
struct timeval disconnect_time, until;
uint64_t timeout_usec;
struct scavenger_message msg;
DATA_BLOB msg_blob;
struct server_id_buf tmp;
if (fsp->op == NULL) {
return;
}
nttime_to_timeval(&disconnect_time, fsp->op->global->disconnect_time);
timeout_usec = 1000 * fsp->op->global->durable_timeout_msec;
until = timeval_add(&disconnect_time,
timeout_usec / 1000000,
timeout_usec % 1000000);
ZERO_STRUCT(msg);
msg.file_id = fsp->file_id;
msg.open_persistent_id = fsp->op->global->open_persistent_id;
msg.until = timeval_to_nttime(&until);
DEBUG(10, ("smbd: %s mark file %s as disconnected at %s with timeout "
"at %s in %fs\n",
server_id_str_buf(self, &tmp),
file_id_string_tos(&fsp->file_id),
timeval_string(talloc_tos(), &disconnect_time, true),
timeval_string(talloc_tos(), &until, true),
fsp->op->global->durable_timeout_msec/1000.0));
SMB_ASSERT(server_id_is_disconnected(&fsp->op->global->server_id));
SMB_ASSERT(!server_id_equal(&self, &smbd_scavenger_state->parent_id));
SMB_ASSERT(!smbd_scavenger_state->am_scavenger);
msg_blob = data_blob_const(&msg, sizeof(msg));
DEBUG(10, ("send message to scavenger\n"));
status = messaging_send(smbd_scavenger_state->msg,
smbd_scavenger_state->parent_id,
MSG_SMB_SCAVENGER,
&msg_blob);
if (!NT_STATUS_IS_OK(status)) {
struct server_id_buf tmp1, tmp2;
DEBUG(2, ("Failed to send message to parent smbd %s "
"from %s: %s\n",
server_id_str_buf(smbd_scavenger_state->parent_id,
&tmp1),
server_id_str_buf(self, &tmp2),
nt_errstr(status)));
}
}
void test_timeval_add() {
const struct timeval
a_plus_b = { 3, 1000000 },
a_plus_c = { 5, 900000 },
b_plus_c = { 6, 100000 };
TS_ASSERT_EQUALS(zero, timeval_add(zero, zero));
TS_ASSERT_EQUALS(a, timeval_add(zero, a));
TS_ASSERT_EQUALS(a, timeval_add(a, zero));
TS_ASSERT_EQUALS(b, timeval_add(zero, b));
TS_ASSERT_EQUALS(c, timeval_add(zero, c));
TS_ASSERT_EQUALS(a_plus_b, timeval_add(a, b));
TS_ASSERT_EQUALS(a_plus_c, timeval_add(a, c));
TS_ASSERT_EQUALS(b_plus_c, timeval_add(b, c));
}
__private_extern__ void
devtimer_set_relative(devtimer_ref timer,
struct timeval rel_time,
devtimer_timeout_func timeout_func,
void * arg1, void * arg2)
{
struct timeval abs_time;
struct timeval current_time;
current_time = devtimer_current_time();
timeval_add(current_time, rel_time, &abs_time);
devtimer_set_absolute(timer, abs_time, timeout_func, arg1, arg2);
return;
}
/*
setup for a unlink retry after a sharing violation
or a non granted oplock
*/
static NTSTATUS pvfs_unlink_setup_retry(struct ntvfs_module_context *ntvfs,
struct ntvfs_request *req,
union smb_unlink *io,
struct odb_lock *lck,
NTSTATUS status)
{
struct pvfs_state *pvfs = talloc_get_type(ntvfs->private_data,
struct pvfs_state);
struct timeval end_time;
if (NT_STATUS_EQUAL(status, NT_STATUS_SHARING_VIOLATION)) {
end_time = timeval_add(&req->statistics.request_time,
0, pvfs->sharing_violation_delay);
} else if (NT_STATUS_EQUAL(status, NT_STATUS_OPLOCK_NOT_GRANTED)) {
end_time = timeval_add(&req->statistics.request_time,
pvfs->oplock_break_timeout, 0);
} else {
return NT_STATUS_INTERNAL_ERROR;
}
return pvfs_odb_retry_setup(ntvfs, req, lck, end_time, io, NULL,
pvfs_retry_unlink);
}
static void aio_child_cleanup(struct event_context *event_ctx,
struct timed_event *te,
struct timeval now,
void *private_data)
{
struct aio_child_list *list = talloc_get_type_abort(
private_data, struct aio_child_list);
struct aio_child *child, *next;
TALLOC_FREE(list->cleanup_event);
for (child = list->children; child != NULL; child = next) {
next = child->next;
if (child->aiocb != NULL) {
DEBUG(10, ("child %d currently active\n",
(int)child->pid));
continue;
}
if (child->dont_delete) {
DEBUG(10, ("Child %d was active since last cleanup\n",
(int)child->pid));
child->dont_delete = false;
continue;
}
DEBUG(10, ("Child %d idle for more than 30 seconds, "
"deleting\n", (int)child->pid));
TALLOC_FREE(child);
child = next;
}
if (list->children != NULL) {
/*
* Re-schedule the next cleanup round
*/
list->cleanup_event = event_add_timed(server_event_context(), list,
timeval_add(&now, 30, 0),
aio_child_cleanup, list);
}
}
coord timeval_round_up(coord c1, coord c2)
{
coord r;
struct tm *tmp;
tmp = localtime((time_t *) &(c1.t.tv_sec));
#ifdef HAVE_TM_GMTOFF
c1.t.tv_sec += tmp->tm_gmtoff;
#endif
if (c2.t.tv_sec == 0) {
r.t.tv_sec = c1.t.tv_sec;
if (c1.t.tv_usec % c2.t.tv_usec == 0)
r.t.tv_usec = c1.t.tv_usec;
else {
r.t.tv_usec = c1.t.tv_usec + (c2.t.tv_usec -
(c1.t.tv_usec % c2.t.tv_usec));
if (r.t.tv_usec >= 1000000) {
r.t.tv_usec -= 1000000;
r.t.tv_sec += 1;
}
}
} else {
r.t.tv_usec = 0;
if (c1.t.tv_sec % c2.t.tv_sec == 0)
r.t.tv_sec = c1.t.tv_sec;
else
r.t.tv_sec = c1.t.tv_sec + (c2.t.tv_sec - (c1.t.tv_sec % c2.t.tv_sec));
}
#ifdef HAVE_TM_GMTOFF
r.t.tv_sec -= tmp->tm_gmtoff;
#endif
timeval_fix(&r);
return r;
#if 0
return timeval_round_down(timeval_add(c1,c2), c2);
#endif
}
static int
add_timer(int ms, int oneshot, server_timer_callback callback, void* arg)
{
struct timeval interval;
timer_callback* cb;
ASSERT (ms || oneshot);
ASSERT(callback != NULL);
interval.tv_sec = ms / 1000;
interval.tv_usec = (ms % 1000) * 1000; /* into micro seconds */
cb = (timer_callback*)calloc(1, sizeof(*cb));
if(!cb)
{
errno = ENOMEM;
return -1;
}
if(gettimeofday(&(cb->at), NULL) == -1)
{
free(cb);
return -1;
}
timeval_add(&(cb->at), &interval);
if (oneshot)
memset(&(cb->interval), 0, sizeof(cb->interval));
else
memcpy(&(cb->interval), &interval, sizeof(cb->interval));
cb->callback = callback;
cb->arg = arg;
cb->next = ctx.timers;
ctx.timers = cb;
return 0;
}
int wait_for_read(sock_t fd, struct timeval *end) {
struct timeval now;
if (end)
gettimeofday(&now, NULL);
for (;;) {
struct timeval tv;
fd_set fds;
int r;
FD_ZERO(&fds);
FD_SET(fd, &fds);
if (end) {
if (timeval_cmp(&now, end) >= 0)
return 1;
tv.tv_sec = tv.tv_usec = 0;
timeval_add(&tv, timeval_diff(end, &now));
}
if ((r = select((int)fd+1, &fds, NULL, NULL, end ? &tv : NULL)) < 0) {
if (errno != EINTR) {
fprintf(stderr, "select() failed: %s\n", strerror(errno));
return -1;
}
} else if (r == 0)
return 1;
else {
if (FD_ISSET(fd, &fds))
return 0;
}
if (end)
gettimeofday(&now, NULL);
}
}
static
void*
snake (void* arg)
{
static int x = 3;
static int y = 3;
struct timeval next_activation;
struct timeval now, timeout;
struct timeval period = { 0, 500000 };
gettimeofday (&next_activation, NULL);
while (1) {
gettimeofday (&now, NULL);
timeval_sub (&timeout, &next_activation, &now);
select (0, NULL, NULL, NULL, &timeout) ;
timeval_add (&next_activation, &next_activation, &period);
x += deltax;
y += deltay;
screen_printxy (x, y, "*");
}
}
int wait_for_write(int fd, struct timeval *end) {
struct timeval now;
if (end)
gettimeofday(&now, NULL);
for (;;) {
struct timeval tv;
fd_set fds;
int r;
FD_ZERO(&fds);
FD_SET(fd, &fds);
if (end) {
if (timeval_cmp(&now, end) >= 0)
return 1;
tv.tv_sec = tv.tv_usec = 0;
timeval_add(&tv, timeval_diff(end, &now));
}
if ((r = select(fd+1, NULL, &fds, NULL, end ? &tv : NULL)) < 0) {
if (errno != EINTR)
return -1;
} else if (r == 0)
return 1;
else {
if (FD_ISSET(fd, &fds))
return 0;
}
if (end)
gettimeofday(&now, NULL);
}
}
void xyzsh_readline_interface_on_curses(char* cmdline, int cursor_point, char** argv, int argc, BOOL exit_in_spite_ofjob_exist, BOOL welcome_msg)
{
gSigChld = FALSE;
gSigWinch = FALSE;
signal(SIGCHLD, handler);
signal(SIGWINCH, handler);
const int maxx = mgetmaxx();
const int maxy = mgetmaxy();
int temulator_y = 0;
int temulator_x = 0;
int temulator_height = maxy;
int temulator_width = maxx;
sTEmulator* temulator = temulator_init(temulator_height, temulator_width);
struct sTEmulatorFunArg arg;
arg.cmdline = cmdline;
arg.cursor_point = cursor_point;
arg.argv = argv;
arg.argc = argc;
arg.exit_in_spite_ofjob_exist = exit_in_spite_ofjob_exist;
arg.welcome_msg = welcome_msg;
temulator_open(temulator, temulator_fun, &arg);
initscr();
start_color();
noecho();
raw();
nodelay(stdscr, TRUE);
keypad(stdscr, TRUE);
curs_set(0);
ESCDELAY=50;
temulator_init_colors();
WINDOW* term_win = newwin(temulator_height, temulator_width, temulator_y, temulator_x);
int pty = temulator->mFD;
fd_set mask, read_ok;
FD_ZERO(&mask);
FD_SET(0, &mask);
FD_SET(pty, &mask);
int dirty = 0;
struct timeval next;
gettimeofday(&next, NULL);
while(1) {
struct timeval tv = { 0, 1000 * 1000 / 100 };
read_ok = mask;
if(select(pty+1, &read_ok, NULL, NULL, &tv) > 0) {
if(FD_ISSET(pty, &read_ok)) {
temulator_read(temulator);
dirty = 1;
}
}
int key;
while((key = getch()) != ERR) {
temulator_write(temulator, key);
dirty = 1;
}
gettimeofday(&tv, NULL);
if(dirty && is_expired(tv, next)) {
temulator_draw_on_curses(temulator, term_win, temulator_y, temulator_x);
wrefresh(term_win);
dirty = 0;
next = timeval_add(tv, slice);
}
if(gSigChld) {
gSigChld = FALSE;
break;
}
if(gSigWinch) {
gSigWinch = 0;
temulator_height = mgetmaxy();
temulator_width = mgetmaxx();
if(temulator_width >= 10 && temulator_height >= 10) {
resizeterm(temulator_height, temulator_width);
wresize(term_win, temulator_height, temulator_width);
temulator_resize(temulator, temulator_height, temulator_width);
dirty = 1;
}
}
}
endwin();
temulator_final(temulator);
}
_PUBLIC_ struct timeval timeval_current_ofs(uint32_t secs, uint32_t usecs)
{
struct timeval tv = timeval_current();
return timeval_add(&tv, secs, usecs);
}
/*
* Function: main
* Purpose:
* Comments:
*/
int main(int argc, char *argv[])
{
int i;
struct sigaction si_sa;
int euid, ruid;
struct host_entry *cursor;
/*
* first things first
* if anything goes wrong anywhere, we want to be super careful to release
* any file descriptor we have on /dev/lkm, and it probably makes sense to
* shutdown the raw socket we have too.
*/
atexit(cleanup);
/*
* get the effective and the real user id's so we know if we are running
* with elevated permissions or not
*/
euid = geteuid();
ruid = getuid();
/* check for the command line arguments */
if(check_options(argc,argv) == 0)
{
return -1;
}
/*
* open the raw socket now. i used to have this further down closer to
* where it was needed, but because you can't change the euid/uid to and
* from root (unless you're the superuser) i can only do this once
*/
if(options & OPT_IPV4)
{
if(open_ipmp_sockets4() == 0) return -1;
}
else if(options & OPT_IPV6)
{
if(open_ipmp_sockets6() == 0) return -1;
}
else
{
if(open_ipmp_sockets4() == 0) return -1;
if(open_ipmp_sockets6() == 0) return -1;
}
/*
* revoke the permissions we requested as we only need them to open a raw
* socket. this is to reduce the impact of any buffer overflow exploits
* that may be present
*/
if(ruid != euid)
{
setreuid(ruid, ruid);
}
/*
* we get the pid so we can identify incoming ipmp packets destined for
* this instance of ipmp_ping
*/
pid = getpid();
/*
* need to know about the addresses this host has
*/
learn_localaddresses();
/*
* in FreeBSD, the actual ping is done by a kernel module that has a syscall
* in it. the kernel module allows the protocol to get a timestamp as close
* to when the mbuf is actually sent to ip_output as possible
*/
#if defined(__FreeBSD__)
if((options & OPT_RAW) == 0)
{
i = get_syscall("ipmp_ping", &syscall_num);
if(i != 0)
{
printerror(i, strerror, "could not get the syscall for ipmp_ping");
return -1;
}
}
#endif
/*
* the -n option means that the user has supplied a list of hosts to
* ping, so we read those entries and put them in an list of hosts with
* details regarding each host. the task of putting hosts into the list
* is handled by read_hosts_file
*
* if the -n option isnt specified, we create a list containing just the
* one host to ping. this way, all the program logic can be used in a
* multitude of situations.
*/
if(options & OPT_NLANR)
{
/*
* if something went wrong parsing the file, we quit.
*/
if(read_hosts_file() == 0)
{
return -1;
}
}
else
{
/*
* if the user didnt specify a host to ping, we bail, telling them
* why first...
*/
if(argc - optind != 1)
{
usage(0);
return -1;
}
/*
* if we can't add a host entry for the host supplied on the command line
* tell the user that it couldnt be parse and cleanup
*/
if(add_host_entry(argv[optind], NULL) == 0)
{
return -1;
}
}
/*
* we now put some handlers into action so if the user ctrl-c's us we have
* the opportunity to tell them what we found out first
* also, if the user specified a timeout, put an alarm in for that so we
* can bail when they tell us to...
*/
sigemptyset(&si_sa.sa_mask);
si_sa.sa_flags = 0;
si_sa.sa_handler = alarm_bells;
if(sigaction(SIGINT, &si_sa, 0) == -1)
{
printerror(errno, strerror, "could not set sigaction for SIGINT");
return -1;
}
if(options & OPT_TIMEOUT)
{
if(sigaction(SIGALRM, &si_sa, 0) == -1)
{
printerror(errno, strerror, "could not set sigaction for SIGALRM");
return -1;
}
}
/*
* we loop for as long as we have not been told to finish up.
* the finish_up loop will exit when
* - there has been an alarm set that goes off
* - a SIGINT is received (from e.g. Ctrl-C)
* - we have got_all_response()'s
*
* this is not an expensive loop in terms of cpu cycles, as the
* recv_echo_response will sleep if there is nothing to recv until we have
* told it to stop blocking - typically one second or whatever the between
* timeout is.
*
* the loop does two things:
* - sends echo requests
* - receives echo responses
*
* the loop sends packets, pausing for however long the timeout is set for
* between packets. this pause is implemented in the recv_echo_response
* function in a call to select(2). if we cannot send a request to one of
* them, we bail, as this probably means the syscall could not be called.
*
* the loop recv's the response and associates the packet with a host_entry
* we then parse that response for the host entry, and then check if we have
* now got all the responses we are looking for. if we have, we exit the
* loop by setting the finish_up flag
*/
sent_all_requests = 0;
i = 0;
cursor = head;
while(finish_up == 0)
{
while(sent_all_requests == 0)
{
if(send_echo_request(cursor) != 0)
{
return -1;
}
cursor->tx++;
if(cursor->tx == count)
{
cursor = cursor->next;
if(cursor == NULL)
{
sent_all_requests = 1;
alarm(timeout);
break;
}
}
if(wait_between > 0)
{
gettimeofday(&wait_between_tv, &tz);
timeval_add(&wait_between_tv, wait_between);
break;
}
}
while(time_to_send_request() == 0 && finish_up == 0)
{
if(recv_echo_responses() > 0)
{
if(got_all_responses() == 1)
{
finish_up = 1;
}
}
}
}
/*
* if we have been given a list of hosts to ping, we have to print out which
* hosts did not give us a reply
*/
if(options & OPT_NLANR)
{
show_loss();
}
return 0;
}
/**
* Send reply to mesh reply entry
* @param m: mesh state to send it for.
* @param rcode: if not 0, error code.
* @param rep: reply to send (or NULL if rcode is set).
* @param r: reply entry
* @param prev: previous reply, already has its answer encoded in buffer.
*/
static void
mesh_send_reply(struct mesh_state* m, int rcode, struct reply_info* rep,
struct mesh_reply* r, struct mesh_reply* prev)
{
struct timeval end_time;
struct timeval duration;
int secure;
/* examine security status */
if(m->s.env->need_to_validate && (!(r->qflags&BIT_CD) ||
m->s.env->cfg->ignore_cd) && rep &&
rep->security <= sec_status_bogus) {
rcode = LDNS_RCODE_SERVFAIL;
if(m->s.env->cfg->stat_extended)
m->s.env->mesh->ans_bogus++;
}
if(rep && rep->security == sec_status_secure)
secure = 1;
else secure = 0;
if(!rep && rcode == LDNS_RCODE_NOERROR)
rcode = LDNS_RCODE_SERVFAIL;
/* send the reply */
if(prev && prev->qflags == r->qflags &&
prev->edns.edns_present == r->edns.edns_present &&
prev->edns.bits == r->edns.bits &&
prev->edns.udp_size == r->edns.udp_size) {
/* if the previous reply is identical to this one, fix ID */
if(prev->query_reply.c->buffer != r->query_reply.c->buffer)
ldns_buffer_copy(r->query_reply.c->buffer,
prev->query_reply.c->buffer);
ldns_buffer_write_at(r->query_reply.c->buffer, 0,
&r->qid, sizeof(uint16_t));
ldns_buffer_write_at(r->query_reply.c->buffer, 12,
r->qname, m->s.qinfo.qname_len);
comm_point_send_reply(&r->query_reply);
} else if(rcode) {
m->s.qinfo.qname = r->qname;
error_encode(r->query_reply.c->buffer, rcode, &m->s.qinfo,
r->qid, r->qflags, &r->edns);
comm_point_send_reply(&r->query_reply);
} else {
size_t udp_size = r->edns.udp_size;
r->edns.edns_version = EDNS_ADVERTISED_VERSION;
r->edns.udp_size = EDNS_ADVERTISED_SIZE;
r->edns.ext_rcode = 0;
r->edns.bits &= EDNS_DO;
m->s.qinfo.qname = r->qname;
if(!reply_info_answer_encode(&m->s.qinfo, rep, r->qid,
r->qflags, r->query_reply.c->buffer, 0, 1,
m->s.env->scratch, udp_size, &r->edns,
(int)(r->edns.bits & EDNS_DO), secure))
{
error_encode(r->query_reply.c->buffer,
LDNS_RCODE_SERVFAIL, &m->s.qinfo, r->qid,
r->qflags, &r->edns);
}
comm_point_send_reply(&r->query_reply);
}
/* account */
m->s.env->mesh->num_reply_addrs--;
end_time = *m->s.env->now_tv;
timeval_subtract(&duration, &end_time, &r->start_time);
verbose(VERB_ALGO, "query took %d.%6.6d sec",
(int)duration.tv_sec, (int)duration.tv_usec);
m->s.env->mesh->replies_sent++;
timeval_add(&m->s.env->mesh->replies_sum_wait, &duration);
timehist_insert(m->s.env->mesh->histogram, &duration);
if(m->s.env->cfg->stat_extended) {
uint16_t rc = FLAGS_GET_RCODE(ldns_buffer_read_u16_at(r->
query_reply.c->buffer, 2));
if(secure) m->s.env->mesh->ans_secure++;
m->s.env->mesh->ans_rcode[ rc ] ++;
if(rc == 0 && LDNS_ANCOUNT(ldns_buffer_begin(r->
query_reply.c->buffer)) == 0)
m->s.env->mesh->ans_nodata++;
}
}
static void clock_init(void) {
timeval_t now = get_uptime();
clock_event->tev_when = timeval_add(&now, &tick);
cpu_timer_add_event(clock_event);
}
int
server_run()
{
struct timeval* timeout;
struct timeval tv, current;
timer_callback* timcb;
socket_callback* sockcb;
fd_set rfds, wfds;
int r;
/* No watches have been set */
ASSERT(ctx.max_fd > -1);
ctx.stopped = 0;
while(!ctx.stopped)
{
/* Watch for the various fds */
memcpy(&rfds, &ctx.read_fds, sizeof(rfds));
memcpy(&wfds, &ctx.write_fds, sizeof(wfds));
/* Prepare for timers */
timeout = NULL;
if(gettimeofday(¤t, NULL) == -1)
return -1;
/* Cycle through timers */
for(timcb = ctx.timers; timcb; )
{
ASSERT(timcb->callback);
/* Call any timers that have already passed */
if(timeval_compare(¤t, &timcb->at) >= 0)
{
/* Convert to milliseconds, and make the call */
r = (timcb->callback)(timeval_to_ms(current), timcb->arg);
/* Reset timer if so desired */
if (r == 1 && !timeval_empty(&timcb->interval))
{
timeval_add(&timcb->at, &timcb->interval);
/* If the time has already passed, just use current time */
if(timeval_compare(&(timcb->at), ¤t) <= 0)
memcpy(&(timcb->at), ¤t, sizeof(timcb->at));
}
/* Otherwise remove it. Either one shot, or returned 0 */
else
{
timcb = remove_timer(timcb);
continue;
}
}
/* Get soonest timer */
if (!timeout || timeval_compare(&timcb->at, timeout) < 0)
timeout = &timcb->at;
timcb = timcb->next;
}
/* Convert to an offset */
if(timeout)
{
memcpy(&tv, timeout, sizeof(tv));
timeout = &tv;
timeval_subtract(timeout, ¤t);
}
/* fprintf(stderr, "selecting with timeout: ");
timeval_dump(timeout);
fprintf(stderr, "\n"); */
r = select(ctx.max_fd, &rfds, &wfds, NULL, timeout);
if (r < 0)
{
/* Interrupted so try again, and possibly exit */
if (errno == EINTR)
continue;
/* Programmer errors */
ASSERT (errno != EBADF);
ASSERT (errno != EINVAL);
return r;
}
/* Timeout, just jump to timeout processing */
if(r == 0)
continue;
for(sockcb = ctx.callbacks; sockcb; sockcb = sockcb->next)
{
ASSERT(sockcb->fd != -1);
/* Call any that are set */
if (FD_ISSET(sockcb->fd, &rfds))
(sockcb->callback)(sockcb->fd, SERVER_READ, sockcb->arg);
if (FD_ISSET(sockcb->fd, &wfds))
(sockcb->callback)(sockcb->fd, SERVER_WRITE, sockcb->arg);
}
}
return 0;
}
NTSTATUS gensec_ntlmssp_server_negotiate(struct gensec_security *gensec_security,
TALLOC_CTX *out_mem_ctx,
const DATA_BLOB request, DATA_BLOB *reply)
{
struct gensec_ntlmssp_context *gensec_ntlmssp =
talloc_get_type_abort(gensec_security->private_data,
struct gensec_ntlmssp_context);
struct ntlmssp_state *ntlmssp_state = gensec_ntlmssp->ntlmssp_state;
struct auth4_context *auth_context = gensec_security->auth_context;
DATA_BLOB struct_blob;
uint32_t neg_flags = 0;
uint32_t ntlmssp_command, chal_flags;
uint8_t cryptkey[8];
const char *target_name;
NTSTATUS status;
struct timeval tv_now = timeval_current();
/*
* See [MS-NLMP]
*
* Windows NT 4.0, windows_2000: use 30 minutes,
* Windows XP, Windows Server 2003, Windows Vista,
* Windows Server 2008, Windows 7, and Windows Server 2008 R2
* use 36 hours.
*
* Newer systems doesn't check this, likely because the
* connectionless NTLMSSP is no longer supported.
*
* As we expect the AUTHENTICATION_MESSAGE to arrive
* directly after the NEGOTIATE_MESSAGE (typically less than
* as 1 second later). We use a hard timeout of 30 Minutes.
*
* We don't look at AUTHENTICATE_MESSAGE.NtChallengeResponse.TimeStamp
* instead we just remember our own time.
*/
uint32_t max_lifetime = 30 * 60;
struct timeval tv_end = timeval_add(&tv_now, max_lifetime, 0);
/* parse the NTLMSSP packet */
#if 0
file_save("ntlmssp_negotiate.dat", request.data, request.length);
#endif
if (request.length) {
if (request.length > UINT16_MAX) {
DEBUG(1, ("ntlmssp_server_negotiate: reject large request of length %u\n",
(unsigned int)request.length));
return NT_STATUS_INVALID_PARAMETER;
}
if ((request.length < 16) || !msrpc_parse(ntlmssp_state, &request, "Cdd",
"NTLMSSP",
&ntlmssp_command,
&neg_flags)) {
DEBUG(1, ("ntlmssp_server_negotiate: failed to parse NTLMSSP Negotiate of length %u\n",
(unsigned int)request.length));
dump_data(2, request.data, request.length);
return NT_STATUS_INVALID_PARAMETER;
}
debug_ntlmssp_flags(neg_flags);
if (DEBUGLEVEL >= 10) {
struct NEGOTIATE_MESSAGE *negotiate = talloc(
ntlmssp_state, struct NEGOTIATE_MESSAGE);
if (negotiate != NULL) {
status = ntlmssp_pull_NEGOTIATE_MESSAGE(
&request, negotiate, negotiate);
if (NT_STATUS_IS_OK(status)) {
NDR_PRINT_DEBUG(NEGOTIATE_MESSAGE,
negotiate);
}
TALLOC_FREE(negotiate);
}
}
}
status = ntlmssp_handle_neg_flags(ntlmssp_state, neg_flags, "negotiate");
if (!NT_STATUS_IS_OK(status)){
return status;
}
/* Ask our caller what challenge they would like in the packet */
if (auth_context->get_ntlm_challenge) {
status = auth_context->get_ntlm_challenge(auth_context, cryptkey);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(1, ("gensec_ntlmssp_server_negotiate: failed to get challenge: %s\n",
nt_errstr(status)));
return status;
}
} else {
DEBUG(1, ("gensec_ntlmssp_server_negotiate: backend doesn't give a challenge\n"));
return NT_STATUS_NOT_IMPLEMENTED;
}
/* The flags we send back are not just the negotiated flags,
* they are also 'what is in this packet'. Therfore, we
* operate on 'chal_flags' from here on
*/
chal_flags = ntlmssp_state->neg_flags;
ntlmssp_state->server.challenge_endtime = timeval_to_nttime(&tv_end);
/* get the right name to fill in as 'target' */
target_name = ntlmssp_target_name(ntlmssp_state,
neg_flags, &chal_flags);
if (target_name == NULL)
return NT_STATUS_INVALID_PARAMETER;
ntlmssp_state->chal = data_blob_talloc(ntlmssp_state, cryptkey, 8);
ntlmssp_state->internal_chal = data_blob_talloc(ntlmssp_state,
cryptkey, 8);
/* This creates the 'blob' of names that appears at the end of the packet */
if (chal_flags & NTLMSSP_NEGOTIATE_TARGET_INFO) {
enum ndr_err_code err;
struct AV_PAIR *pairs = NULL;
uint32_t count = 5;
pairs = talloc_zero_array(ntlmssp_state, struct AV_PAIR, count + 1);
if (pairs == NULL) {
return NT_STATUS_NO_MEMORY;
}
pairs[0].AvId = MsvAvNbDomainName;
pairs[0].Value.AvNbDomainName = target_name;
pairs[1].AvId = MsvAvNbComputerName;
pairs[1].Value.AvNbComputerName = ntlmssp_state->server.netbios_name;
pairs[2].AvId = MsvAvDnsDomainName;
pairs[2].Value.AvDnsDomainName = ntlmssp_state->server.dns_domain;
pairs[3].AvId = MsvAvDnsComputerName;
pairs[3].Value.AvDnsComputerName= ntlmssp_state->server.dns_name;
if (!ntlmssp_state->force_old_spnego) {
pairs[4].AvId = MsvAvTimestamp;
pairs[4].Value.AvTimestamp =
timeval_to_nttime(&tv_now);
count += 1;
pairs[5].AvId = MsvAvEOL;
} else {
pairs[4].AvId = MsvAvEOL;
}
ntlmssp_state->server.av_pair_list.count = count;
ntlmssp_state->server.av_pair_list.pair = pairs;
err = ndr_push_struct_blob(&struct_blob,
ntlmssp_state,
&ntlmssp_state->server.av_pair_list,
(ndr_push_flags_fn_t)ndr_push_AV_PAIR_LIST);
if (!NDR_ERR_CODE_IS_SUCCESS(err)) {
return NT_STATUS_NO_MEMORY;
}
} else {
/**
* Writes a packet into the pipe
*/
void PCAPExporterPipe::receive(Packet* packet)
{
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() called");
if (onRestart){
DPRINTF("Dropping incoming packet, as attached process is not ready");
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
packet->removeReference();
return;
}
if (fifoReaderPid == 0){
msg(MSG_VDEBUG, "fifoReaderPid = 0...this might happen during reconfiguration");
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
packet->removeReference();
return;
}
if (restartInterval) {
if (nextRestart.tv_sec==0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): updating nextRestart");
nextRestart = packet->timestamp;
struct timeval tv = { restartInterval/1000, (restartInterval % 1000)*1000 };
timeval_add(&nextRestart, &tv);
} else if (compareTime(nextRestart, packet->timestamp)<0) {
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): restarting process");
// we need to unregister our signal handlers, as we get race conditions with the signal handler for restarting the process
unregisterSignalHandlers();
stopProcess();
startProcess();
registerSignalHandlers();
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive(): updating nextRestart");
timeval tvdiff;
timeval_subtract(&tvdiff, &packet->timestamp, &nextRestart);
uint32_t msdiff = tvdiff.tv_sec*1000+tvdiff.tv_usec/1000;
uint32_t mswait = (msdiff/restartInterval+1)*restartInterval;
tvdiff.tv_sec = mswait/1000;
tvdiff.tv_usec = (mswait%1000)*1000;
timeval_add(&nextRestart, &tvdiff);
}
}
// write packet
static struct pcap_pkthdr packetHeader;
packetHeader.ts = packet->timestamp;
packetHeader.caplen = packet->data_length;
packetHeader.len = packet->pcapPacketLength;
struct iovec wvec[2];
wvec[0].iov_base = &packetHeader;
wvec[0].iov_len = sizeof(packetHeader);
wvec[1].iov_base = packet->data;
wvec[1].iov_len = packetHeader.caplen;
if (writev(pcapFile, wvec, 2)!=(ssize_t)(sizeof(packetHeader)+packetHeader.caplen)) {
if (errno==EAGAIN) {
// pipe is full, drop packet
statBytesDropped += packet->data_length;
statPktsDropped++;
} else
THROWEXCEPTION("PCAPExporterPipe: failed to write, error %u (%s)", errno, strerror(errno));
} else {
statBytesForwarded += packet->data_length;
statPktsForwarded++;
}
packet->removeReference();
DPRINTFL(MSG_VDEBUG, "PCAPExporterPipe::receive() ended");
}
static NTSTATUS wreplsrv_scavenging_owned_records(struct wreplsrv_service *service, TALLOC_CTX *tmp_mem)
{
NTSTATUS status;
struct winsdb_record *rec = NULL;
struct ldb_result *res = NULL;
const char *owner_filter;
const char *filter;
uint32_t i;
int ret;
time_t now = time(NULL);
const char *now_timestr;
const char *action;
const char *old_state=NULL;
const char *new_state=NULL;
uint32_t modify_flags;
BOOL modify_record;
BOOL delete_record;
BOOL delete_tombstones;
struct timeval tombstone_extra_time;
now_timestr = ldb_timestring(tmp_mem, now);
NT_STATUS_HAVE_NO_MEMORY(now_timestr);
owner_filter = wreplsrv_owner_filter(service, tmp_mem,
service->wins_db->local_owner);
NT_STATUS_HAVE_NO_MEMORY(owner_filter);
filter = talloc_asprintf(tmp_mem,
"(&%s(objectClass=winsRecord)"
"(expireTime<=%s))",
owner_filter, now_timestr);
NT_STATUS_HAVE_NO_MEMORY(filter);
ret = ldb_search(service->wins_db->ldb, NULL, LDB_SCOPE_SUBTREE, filter, NULL, &res);
if (ret != LDB_SUCCESS) return NT_STATUS_INTERNAL_DB_CORRUPTION;
talloc_steal(tmp_mem, res);
DEBUG(10,("WINS scavenging: filter '%s' count %d\n", filter, res->count));
tombstone_extra_time = timeval_add(&service->startup_time,
service->config.tombstone_extra_timeout,
0);
delete_tombstones = timeval_expired(&tombstone_extra_time);
for (i=0; i < res->count; i++) {
/*
* we pass '0' as 'now' here,
* because we want to get the raw timestamps which are in the DB
*/
status = winsdb_record(service->wins_db, res->msgs[i], tmp_mem, 0, &rec);
NT_STATUS_NOT_OK_RETURN(status);
talloc_free(res->msgs[i]);
modify_flags = 0;
modify_record = False;
delete_record = False;
switch (rec->state) {
case WREPL_STATE_ACTIVE:
old_state = "active";
new_state = "active";
if (!rec->is_static) {
new_state = "released";
rec->state = WREPL_STATE_RELEASED;
rec->expire_time= service->config.tombstone_interval + now;
}
modify_flags = 0;
modify_record = True;
break;
case WREPL_STATE_RELEASED:
old_state = "released";
new_state = "tombstone";
rec->state = WREPL_STATE_TOMBSTONE;
rec->expire_time= service->config.tombstone_timeout + now;
modify_flags = WINSDB_FLAG_ALLOC_VERSION | WINSDB_FLAG_TAKE_OWNERSHIP;
modify_record = True;
break;
case WREPL_STATE_TOMBSTONE:
old_state = "tombstone";
new_state = "tombstone";
if (!delete_tombstones) break;
new_state = "deleted";
delete_record = True;
break;
case WREPL_STATE_RESERVED:
DEBUG(0,("%s: corrupted record: %s\n",
__location__, nbt_name_string(rec, rec->name)));
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
if (modify_record) {
action = "modify";
ret = winsdb_modify(service->wins_db, rec, modify_flags);
} else if (delete_record) {
action = "delete";
ret = winsdb_delete(service->wins_db, rec);
} else {
action = "skip";
ret = NBT_RCODE_OK;
}
if (ret != NBT_RCODE_OK) {
DEBUG(1,("WINS scavenging: failed to %s name %s (owned:%s -> owned:%s): error:%u\n",
action, nbt_name_string(rec, rec->name), old_state, new_state, ret));
} else {
DEBUG(4,("WINS scavenging: %s name: %s (owned:%s -> owned:%s)\n",
action, nbt_name_string(rec, rec->name), old_state, new_state));
}
talloc_free(rec);
}
return NT_STATUS_OK;
}
static bool test_usermod(struct torture_context *tctx, struct dcerpc_pipe *p,
TALLOC_CTX *mem_ctx,
struct policy_handle *handle, int num_changes,
struct libnet_rpc_usermod *mod, char **username)
{
const char* logon_scripts[] = { "start_login.cmd", "login.bat", "start.cmd" };
const char* home_dirs[] = { "\\\\srv\\home", "\\\\homesrv\\home\\user", "\\\\pdcsrv\\domain" };
const char* home_drives[] = { "H:", "z:", "I:", "J:", "n:" };
const char *homedir, *homedrive, *logonscript;
const uint32_t flags[] = { (ACB_DISABLED | ACB_NORMAL | ACB_PW_EXPIRED),
(ACB_NORMAL | ACB_PWNOEXP),
(ACB_NORMAL | ACB_PW_EXPIRED) };
NTSTATUS status;
struct timeval now;
enum test_fields testfld;
int i;
ZERO_STRUCT(*mod);
srandom((unsigned)time(NULL));
mod->in.username = talloc_strdup(mem_ctx, *username);
mod->in.domain_handle = *handle;
torture_comment(tctx, "modifying user (%d simultaneous change(s))\n",
num_changes);
torture_comment(tctx, "fields to change: [");
for (i = 0; i < num_changes && i <= USER_FIELD_LAST; i++) {
const char *fldname;
testfld = (random() % USER_FIELD_LAST) + 1;
GetTimeOfDay(&now);
switch (testfld) {
case acct_name:
continue_if_field_set(mod->in.change.account_name);
mod->in.change.account_name = talloc_asprintf(mem_ctx, TEST_CHG_ACCOUNTNAME,
(int)(random() % 100));
mod->in.change.fields |= USERMOD_FIELD_ACCOUNT_NAME;
fldname = "account_name";
*username = talloc_strdup(mem_ctx, mod->in.change.account_name);
break;
case acct_full_name:
continue_if_field_set(mod->in.change.full_name);
mod->in.change.full_name = talloc_asprintf(mem_ctx, TEST_CHG_FULLNAME,
(int)random(), (int)random());
mod->in.change.fields |= USERMOD_FIELD_FULL_NAME;
fldname = "full_name";
break;
case acct_description:
continue_if_field_set(mod->in.change.description);
mod->in.change.description = talloc_asprintf(mem_ctx, TEST_CHG_DESCRIPTION,
random());
mod->in.change.fields |= USERMOD_FIELD_DESCRIPTION;
fldname = "description";
break;
case acct_home_directory:
continue_if_field_set(mod->in.change.home_directory);
homedir = home_dirs[random() % (sizeof(home_dirs)/sizeof(char*))];
mod->in.change.home_directory = talloc_strdup(mem_ctx, homedir);
mod->in.change.fields |= USERMOD_FIELD_HOME_DIRECTORY;
fldname = "home_directory";
break;
case acct_home_drive:
continue_if_field_set(mod->in.change.home_drive);
homedrive = home_drives[random() % (sizeof(home_drives)/sizeof(char*))];
mod->in.change.home_drive = talloc_strdup(mem_ctx, homedrive);
mod->in.change.fields |= USERMOD_FIELD_HOME_DRIVE;
fldname = "home_drive";
break;
case acct_comment:
continue_if_field_set(mod->in.change.comment);
mod->in.change.comment = talloc_asprintf(mem_ctx, TEST_CHG_COMMENT,
random(), random());
mod->in.change.fields |= USERMOD_FIELD_COMMENT;
fldname = "comment";
break;
case acct_logon_script:
continue_if_field_set(mod->in.change.logon_script);
logonscript = logon_scripts[random() % (sizeof(logon_scripts)/sizeof(char*))];
mod->in.change.logon_script = talloc_strdup(mem_ctx, logonscript);
mod->in.change.fields |= USERMOD_FIELD_LOGON_SCRIPT;
fldname = "logon_script";
break;
case acct_profile_path:
continue_if_field_set(mod->in.change.profile_path);
mod->in.change.profile_path = talloc_asprintf(mem_ctx, TEST_CHG_PROFILEPATH,
(long int)random(), (unsigned int)random());
mod->in.change.fields |= USERMOD_FIELD_PROFILE_PATH;
fldname = "profile_path";
break;
case acct_expiry:
continue_if_field_set(mod->in.change.acct_expiry);
now = timeval_add(&now, (random() % (31*24*60*60)), 0);
mod->in.change.acct_expiry = (struct timeval *)talloc_memdup(mem_ctx, &now, sizeof(now));
mod->in.change.fields |= USERMOD_FIELD_ACCT_EXPIRY;
fldname = "acct_expiry";
break;
case acct_flags:
continue_if_field_set(mod->in.change.acct_flags);
mod->in.change.acct_flags = flags[random() % ARRAY_SIZE(flags)];
mod->in.change.fields |= USERMOD_FIELD_ACCT_FLAGS;
fldname = "acct_flags";
break;
default:
fldname = talloc_asprintf(mem_ctx, "unknown_field (%d)", testfld);
break;
}
torture_comment(tctx, ((i < num_changes - 1) ? "%s," : "%s"), fldname);
}
torture_comment(tctx, "]\n");
status = libnet_rpc_usermod(p, mem_ctx, mod);
torture_assert_ntstatus_ok(tctx, status, "Failed to call sync libnet_rpc_usermod");
return true;
}
