static void setitimer_intrinsic (void)
{
SLang_Ref_Type *interval_ref = NULL, *value_ref = NULL;
int w;
struct itimerval new_value, old_value;
double interval = 0.0, value;
int argc = SLang_Num_Function_Args;
if (SLang_peek_at_stack () == SLANG_REF_TYPE)
{
if (-1 == SLang_pop_ref (&value_ref))
return;
argc--;
if (SLang_peek_at_stack() == SLANG_REF_TYPE)
{
interval_ref = value_ref;
if (-1 == SLang_pop_ref (&value_ref))
goto free_and_return;
argc--;
}
}
switch (argc)
{
case 3:
if (-1 == SLang_pop_double (&interval))
goto free_and_return;
/* drop */
case 2:
default:
if ((-1 == SLang_pop_double (&value))
|| (-1 == SLang_pop_int (&w)))
goto free_and_return;
}
double_to_timeval (interval, &new_value.it_interval);
double_to_timeval (value, &new_value.it_value);
if (-1 == setitimer (w, &new_value, &old_value))
{
SLerrno_set_errno (errno);
SLang_verror (SL_OS_Error, "setitimer failed: %s", SLerrno_strerror (errno));
goto free_and_return;
}
if (value_ref != NULL)
{
value = timeval_to_double (&old_value.it_value);
if (-1 == SLang_assign_to_ref (value_ref, SLANG_DOUBLE_TYPE, &value))
goto free_and_return;
}
if (interval_ref != NULL)
{
interval = timeval_to_double (&old_value.it_interval);
if (-1 == SLang_assign_to_ref (interval_ref, SLANG_DOUBLE_TYPE, &interval))
goto free_and_return;
}
free_and_return:
if (value_ref != NULL)
SLang_free_ref (value_ref);
if (interval_ref != NULL)
SLang_free_ref (interval_ref);
}
/*
* [ application_name local_ip local_port cname sdp_file [-t trace_file] ]
*/
int main(int argc, char **argv){
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv); /* parse the sdp file */
/* The application will sleep "rtp_start_time" time if "rtp_start_time" > 0 when the application is start.
*
* NOTE! This is not the same with Start Time in NCTUns
* EX: if the Start Time in NCTUn is 5, and rtp_start_time is 3,
* then the real time to startup the applicaion is 8.
*/
if (rtp_start_time > 0)
usleep( ((int) rtp_start_time * 1000000) );
initial_session(argc, argv, sid); /* set local receive addr, CNAME, and startup the connectoin */
if (is_audio) /* media type is audio */
delay = (ms_pkt / 1000.);
else
delay = (1. / framerate);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt); /* get source rtp socket */
if (err)
err_handle(err);
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt); /* get source rtcp socket */
if (err)
err_handle(err);
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
now = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
// packet_size = (int) ( (bits_per_sample / 8.) * sampling_rate * delay);
while ((now - starttime) <= rtp_interval) {
memcpy(&rfds, &afds, sizeof(rfds));
err = get_rtcp_timeout(sid, &timeout_tv); /* get the send_rtcp_packet time */
if (err)
err_handle(err);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire(); /* rtcp on_expire */
if (err)
err_handle(err);
err = get_rtcp_timeout(sid, &timeout_tv); /* get the send_rtcp_packet time */
if (err)
err_handle(err);
}
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err)
err_handle(err);
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err)
err_handle(err);
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while ((now - starttime) <= rtp_interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
void serve_clients(struct server *s, struct frame_buffers *fbs, double timeout) {
fd_set read_set, write_set;
int select_result, sock, client_sock, highest_sock_num = max(s->sock4, s->sock6);
struct sockaddr_storage client_addr;
socklen_t client_addr_len = sizeof(client_addr);
struct client *c;
struct timeval timeout_tv;
double now;
while (timeout > 0) {
FD_ZERO(&read_set);
FD_ZERO(&write_set);
if (s->sock4 >= 0) {
FD_SET(s->sock4, &read_set);
}
if (s->sock6 >= 0) {
FD_SET(s->sock6, &read_set);
}
for (sock = 0; sock < FD_SETSIZE; sock++) {
c = s->clients[sock];
if (c != NULL) {
FD_SET(c->sock, &read_set);
FD_SET(c->sock, &write_set);
highest_sock_num = max(highest_sock_num, c->sock);
}
}
double_to_timeval(timeout, &timeout_tv);
now = gettime();
if ((select_result = select(highest_sock_num + 1, &read_set, &write_set, NULL, &timeout_tv)) < 0) {
serrchk("select() failed");
}
if (!select_result) {
break;
}
for (sock = 0; sock <= highest_sock_num; sock++) {
// Look over read_set
if (FD_ISSET(sock, &read_set)) {
if (sock == s->sock4 || sock == s->sock6) {
// Accept client
if ((client_sock = accept(sock, (struct sockaddr *) &client_addr, &client_addr_len)) < 0) {
serrchk("accept() failed");
}
add_client(s, client_sock, &client_addr, fbs);
continue;
}
else {
c = s->clients[sock];
if (c != NULL) {
read_request(s, c, fbs);
}
}
}
// Look over write set
if (FD_ISSET(sock, &write_set)) {
c = s->clients[sock];
if (c != NULL) {
respond_to_client(s, c);
}
}
// Prune clinets that are not communicating
if ((c = s->clients[sock]) != NULL) {
if (now - c->last_communication > KEEP_ALIVE_TIMEOUT) {
remove_client(s, c);
}
}
}
timeout -= gettime() - now;
}
}
int main(int argc, char **argv){
/* setting commad line information */
local_ip = argv[1];
local_port = atoi(argv[2]);
cname = argv[3];
proto = udp;
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv);
if (rtp_start_time > 0) {
usleep( ((int) rtp_start_time * 1000000) );
}
if ((i = initial_session(argc, argv, sid))) {
printf("WARNING : initial_session warning = %d\n", i);
}
else {
printf("initial_session is ok\n");
}
if (is_audio) {
delay = (ms_pkt / 1000.);
}
else {
delay = (1. / framerate); // unit: ms/sec. we assume that 300 samples/frame,
}
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
packet_size = (int) ( bits_per_sample * sampling_rate * delay / 8.);
/* original_bw = min_bw = 50, so we use the same pkt size */
minbw_pktsize = packet_size;
printf("bits_per_sample = %lf, (bits_per_sample/8.) = %lf\n", bits_per_sample, (bits_per_sample/8.));
printf("sampling_rate = %lf\n", sampling_rate);
printf("delay = %lf\n", delay);
printf("packet_size = %d\n", packet_size);
fflush(stdout);
/* the bandwidth wa are using, 30 = frames/sec */
cur_bw = get_cur_bw(packet_size);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt);
if (err) {
err_handle(err);
}
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt);
if (err) {
err_handle(err);
}
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
nexttime = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
printf("rtp_interval = %f\n", rtp_interval);
fflush(stdout);
while (rtp_interval >= 0) {
memcpy(&rfds, &afds, sizeof(rfds));
if (RTP_MAX_PKT_SIZE < packet_size){
fprintf(stderr, "RTP_MAX_PKT_SIZE < reads\n");
continue;
}
addtimestamp = ((int) packet_size * (bits_per_sample / 8.) );
err = rtp_send(sid, marker, addtimestamp, codec_num, (int8 *)sendbuf, packet_size);
if (err) {
err_handle(err);
}
marker = 0; /* not the first packet of talkspurt */
rtp_interval -= delay;
nexttime += delay;
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
while (now < nexttime) { /* send next packet until now >= nexttime */
//printf("now = %lf\n", now);
//printf("nexttime = %lf\n", nexttime);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire();
if (err) {
err_handle(err);
}
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
printf("timeval_to_double(timeout_tv) = %lf\n", timeval_to_double(timeout_tv));
}
/* BECAREFUL, if we disable RTCP, the timeval we get will be 0 */
if (timeval_to_double(timeout_tv) == 0 || nexttime < timeval_to_double(timeout_tv)) {
nexttime_tv = double_to_timeval(nexttime - now);
}
else {
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
}
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
//exit(1);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
adapt_bw(get_recent_recv_loosrate(sid, &ssrc));
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while(now < nexttime)
} // while (interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
/*
* You call this to register a timer callback.
*
* The arguments:
* update: This should be 1 if we're updating the specified refnum
* refnum_want: The refnum requested. This should only be sepcified
* by the user, functions wanting callbacks should specify
* the empty string, which means "dont care".
* The rest of the arguments are dependant upon the value of "callback"
* -- if "callback" is NULL then:
* callback: NULL
* what: some ircII commands to run when the timer goes off
* subargs: what to use to expand $0's, etc in the 'what' variable.
*
* -- if "callback" is non-NULL then:
* callback: function to call when timer goes off
* what: argument to pass to "callback" function. Should be some
* non-auto storage, perhaps a struct or a malloced char *
* array. The caller is responsible for disposing of this
* area when it is called, since the timer mechanism does not
* know anything of the nature of the argument.
* subargs: should be NULL, its ignored anyhow.
*/
char *add_timer (int update, const char *refnum_want, double interval, long events, int (callback) (void *), void *commands, const char *subargs, TimerDomain domain, int domref, int cancelable)
{
Timer *ntimer, *otimer = NULL;
char * refnum_got = NULL;
Timeval right_now;
char * retval;
/* XXX Eh, maybe it's a hack to check this here. */
if (interval < 0.01 && events == -1)
{
say("You can't infinitely repeat a timer that runs more "
"than 100 times a second.");
return NULL;
}
right_now = get_time(NULL);
if (update)
{
if (!(otimer = get_timer(refnum_want)))
update = 0; /* Ok so we're not updating! */
}
if (update)
{
unlink_timer(otimer);
ntimer = clone_timer(otimer);
delete_timer(otimer);
if (interval != -1)
{
ntimer->interval = double_to_timeval(interval);
ntimer->time = time_add(right_now, ntimer->interval);
}
if (events != -2)
ntimer->events = events;
if (callback)
{
/* Delete the previous timer, if necessary */
if (ntimer->command)
new_free(&ntimer->command);
if (ntimer->subargs)
new_free(&ntimer->subargs);
ntimer->callback = callback;
/* Unfortunately, command is "sometimes const". */
ntimer->callback_data = commands;
ntimer->subargs = NULL;
}
else
{
if (ntimer->callback)
ntimer->callback = NULL;
malloc_strcpy(&ntimer->command, (const char *)commands);
malloc_strcpy(&ntimer->subargs, subargs);
}
if (domref != -1)
ntimer->domref = domref;
}
else
{
if (create_timer_ref(refnum_want, &refnum_got) == -1)
{
say("TIMER: Refnum '%s' already exists", refnum_want);
return NULL;
}
ntimer = new_timer();
ntimer->ref = refnum_got;
ntimer->interval = double_to_timeval(interval);
ntimer->time = time_add(right_now, ntimer->interval);
ntimer->events = events;
ntimer->callback = callback;
/* Unfortunately, command is "sometimes const". */
if (callback)
ntimer->callback_data = commands;
else
malloc_strcpy(&ntimer->command, (const char *)commands);
malloc_strcpy(&ntimer->subargs, subargs);
ntimer->domain = domain;
ntimer->domref = domref;
ntimer->cancelable = cancelable;
ntimer->fires = 0;
}
schedule_timer(ntimer);
retval = ntimer->ref;
return retval; /* Eliminates a specious warning from gcc */
}
int main(int argc, char **argv){
/* create a rtp session, we will assign unique value to identify */
err = rtp_create(&sid);
if (err) {
err_handle(err);
}
sdp_parse(sid, argv); /* parse the sdp file */
/* The application will sleep "rtp_start_time" time if "rtp_start_time" > 0 when the application is start.
*
* NOTE! This is not the same with Start Time in NCTUns
* EX: if the Start Time in NCTUn is 5, and rtp_start_time is 3,
* then the real time to startup the applicaion is 8.
*/
if (rtp_start_time > 0) {
usleep( ((int) rtp_start_time * 1000000) );
}
initial_session(argc, argv, sid); /* set local receive addr, CNAME, and startup the connectoin */
if (!trans_mode) { /* throughput is static */
if (is_audio) /* media type is audio */
delay = (ms_pkt / 1000.);
else
delay = (1. / framerate);
/* bytes of each packet = ((bits/sample) / 8 ) * (clock rate) * ( each delay of packet in sec ) */
packet_size = (int) ( (bits_per_sample / 8.) * sampling_rate * delay);
if (RTP_MAX_PKT_SIZE < packet_size) {
fprintf(stderr, "The packet size is bigger than RTP_MAX_PKT_SIZE\n");
exit(1);
}
}
/* original_bw = min_bw = 50, so we use the same pkt size */
minbw_pktsize = packet_size;
printf("bits_per_sample = %lf, (bits_per_sample/8.) = %lf\n", bits_per_sample, (bits_per_sample/8.));
printf("sampling_rate = %lf\n", sampling_rate);
printf("delay = %lf\n", delay);
printf("packet_size = %d\n", packet_size);
/* the bandwidth wa are using, 30 = frames/sec */
cur_bw = get_cur_bw(packet_size);
err = rtp_get_sour_rtpsocket(sid, &rtp_sockt);
if (err) {
err_handle(err);
}
err = rtp_get_sour_rtcpsocket(sid, &rtcp_sockt);
if (err) {
err_handle(err);
}
if (rtp_sockt > nfds || rtcp_sockt > nfds) {
if (rtp_sockt > rtcp_sockt)
nfds = rtp_sockt;
else
nfds = rtcp_sockt;
}
FD_ZERO(&afds);
FD_ZERO(&rfds);
FD_SET(rtp_sockt, &afds);
FD_SET(rtcp_sockt, &afds);
gettimeofday(&start_tv, NULL);
starttime = (start_tv.tv_sec + start_tv.tv_usec / 1000000.);
nexttime = starttime;
rtp_interval = rtp_stop_time - rtp_start_time;
printf("rtp_interval = %f\n", rtp_interval);
fflush(stdout);
while (rtp_interval >= 0) {
memcpy(&rfds, &afds, sizeof(rfds));
if (RTP_MAX_PKT_SIZE < packet_size){
fprintf(stderr, "RTP_MAX_PKT_SIZE < reads\n");
continue;
}
addtimestamp = ((int) packet_size * (bits_per_sample / 8.) );
err = rtp_send(sid, marker, addtimestamp, codec_num, (int8 *)sendbuf, packet_size);
if (err) {
err_handle(err);
}
marker = 0; /* not the first packet of talkspurt */
rtp_interval -= delay;
nexttime += delay;
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
while (now < nexttime) { /* send next packet until now >= nexttime */
//printf("now = %lf\n", now);
//printf("nexttime = %lf\n", nexttime);
if (time_expire(&timeout_tv, &now_tv)) {
err = rtp_check_on_expire();
if (err) {
err_handle(err);
}
err = get_rtcp_timeout(sid, &timeout_tv);
if (err) {
err_handle(err);
}
printf("timeval_to_double(timeout_tv) = %lf\n", timeval_to_double(timeout_tv));
}
/* BECAREFUL, if we disable RTCP, the timeval we get will be 0 */
if (timeval_to_double(timeout_tv) == 0 || nexttime < timeval_to_double(timeout_tv)) {
nexttime_tv = double_to_timeval(nexttime - now);
}
else {
nexttime_tv = double_to_timeval(timeval_to_double(timeout_tv) - now);
}
if (select(nfds + 1, &rfds, (fd_set *)0, (fd_set *)0, &nexttime_tv) < 0) {
if (errno == EINTR)
continue;
else {
printf("nexttime_tv.tv_sec = %ld\n", nexttime_tv.tv_sec);
printf("nexttime_tv.tv_usec = %ld\n", nexttime_tv.tv_usec);
printf("select error: %d\n", errno);
//exit(1);
}
}
if (FD_ISSET(rtp_sockt, &rfds)) {
err = on_receive(sid, rtp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
}
else if (FD_ISSET(rtcp_sockt, &rfds)) {
err = on_receive(sid, rtcp_sockt, recvbuf, &recbuflen);
if (err) {
err_handle(err);
}
adapt_bw(get_recent_recv_loosrate(sid, &ssrc));
}
gettimeofday(&now_tv, NULL);
now = (now_tv.tv_sec + now_tv.tv_usec / 1000000.);
} // while(now < nexttime)
} // while (interval)
err = rtp_close_connection(sid, reason);
if (err) {
err_handle(err);
}
err = rtp_delete(sid);
if (err) {
err_handle(err);
}
return 0;
}
/*
* You call this to register a timer callback.
*
* The arguments:
* update: This should be 1 if we're updating the specified refnum
* refnum_want: The refnum requested.
* (1) User-supplied for /TIMER timers
* (2) the empty string for system timers ("dont care")
* interval: How long until the timer should fire;
* (1) for repeating timers (events != 1), the timer will
* fire with this interval.
* (2) for "snap" timers, the first fire will be the next
* time time() % interval == 0.
* events: The number of times this event should fire.
* (1) The value -1 means "repeat forever"
* (2) Timers automatically delete after they fire the
* requested number of times.
*
* Scenario 1: You want to run ircII commands (/TIMER timers)
* | callback: NULL
* | commands: some ircII commands to run when the timer goes off
* | subargs: what to use to expand $0's, etc in the 'what' variable.
*
* Scenario 2: You want to call an internal function (system timers)
* | callback: function to call when timer goes off
* | commands: argument to pass to "callback" function. Should be some
* | non-auto storage, perhaps a struct or a malloced char *
* | array. The caller is responsible for disposing of this
* | area when it is called, since the timer mechanism does not
* | know anything of the nature of the argument.
* | subargs: should be NULL, its ignored anyhow.
*
* domain: What the TIMER should bind to:
* (a) SERVER_TIMER - 'domref' refers to a server refnum.
* Each time this timer runs, set from_server to 'domref'
* and set the current window to whatever 'domref's
* current window is at that time.
* (b) WINDOW_TIME - 'domref' refers to a window refnum.
* Each time this timer runs, set current_window to
* 'domref' and set the current server to whatever
* 'domref's server is at that time.
* (c) GENERAL_TIMER - 'domref' is ignored.
* Do not save or restore from_server or current_window:
* run in whatever the context is when it goes off.
* domref: Either a server refnum, window refnum, or -1 (see 'domain')
* cancelable: A "Cancelable" timer will not fire if its context cannot be
* restored (ie, the server it is bound to is disconnected or
* deleted; or the window it is bound to is deleted). A normal
* (non-cancelable) timer will turn into a GENERAL_TIMER if its
* context cannot be restored.
* snap: A "snap" timer runs every time (time() % interval == 0).
* This is useful for things that (eg) run at the top of every
* minute (60), hour (3600), or day (86400)
*/
char *add_timer (int update, const char *refnum_want, double interval, long events, int (callback) (void *), void *commands, const char *subargs, TimerDomain domain, int domref, int cancelable, int snap)
{
Timer *ntimer, *otimer = NULL;
char * refnum_got = NULL;
Timeval right_now;
char * retval;
right_now = get_time(NULL);
/*
* We do this first, because if 'interval' is invalid, we don't
* want to do the expensive clone/create/delete operation.
* It is ineligant to check for this error here.
*/
if (update == 1 && interval == -1) /* Not changing the interval */
(void) 0; /* XXX sigh */
else if (interval < 0.01 && events == -1)
{
say("You can't infinitely repeat a timer that runs more "
"than 100 times a second.");
return NULL;
}
/*
* If we say we're updating; but the timer does not exist,
* then we're not updating. ;-)
*/
if (update)
{
if (!(otimer = get_timer(refnum_want)))
update = 0; /* Ok so we're not updating! */
}
/*
* Arrange for an appropriate Timer to be in 'ntimer'.
*/
if (update)
{
unlink_timer(otimer);
ntimer = clone_timer(otimer);
delete_timer(otimer);
}
else
{
if (create_timer_ref(refnum_want, &refnum_got) == -1)
{
say("TIMER: Refnum '%s' already exists", refnum_want);
return NULL;
}
ntimer = new_timer();
ntimer->ref = refnum_got;
}
/* Update the interval */
if (update == 1 && interval == -1)
(void) 0; /* XXX sigh - not updating interval */
else
{
ntimer->interval = double_to_timeval(interval);
if (snap)
{
double x = time_to_next_interval(interval);
ntimer->time = time_add(right_now, double_to_timeval(x));
}
else
ntimer->time = time_add(right_now, ntimer->interval);
}
/* Update the repeat events */
if (update == 1 && events == -2)
(void) 0; /* XXX sigh - not updating events */
else
ntimer->events = events;
/* Update the callback */
if (callback)
{
/* Delete the previous timer, if necessary */
if (ntimer->command)
new_free(&ntimer->command);
if (ntimer->subargs)
new_free(&ntimer->subargs);
ntimer->callback = callback;
/* Unfortunately, command is "sometimes const". */
ntimer->callback_data = commands;
ntimer->subargs = NULL;
}
else
{
ntimer->callback = NULL;
malloc_strcpy(&ntimer->command, (const char *)commands);
malloc_strcpy(&ntimer->subargs, subargs);
}
/* Update the domain refnum */
ntimer->domain = domain;
if (update == 1 && domref == -1)
(void) 0; /* XXX sigh - not updating domref */
else
ntimer->domref = domref;
/* Update the cancelable */
if (update == 1 && cancelable == -1)
(void) 0; /* XXX sigh - not updating cancelable */
else
ntimer->cancelable = cancelable;
/* Schedule up the new/updated timer! */
schedule_timer(ntimer);
retval = ntimer->ref;
return retval; /* Eliminates a specious warning from gcc */
}
