int set_incantation(t_stck *s, int fd, int pause, int (*funct)())
{
int i;
int *players;
int flag;
int ressource;
i = 0;
flag = 1;
players = get_players_from_case(s, fd);
ressource = check_ressource_for_incant(s, fd);
while (players[i])
{
flag = s->fds[players[i]].level == s->fds[fd].level ? 1 : 0;
i++;
}
if (flag && (i + 1) == gl_inc_tok[s->fds[fd].level - 1].nb_players
&& ressource)
{
set_timeout(s, fd, pause, funct);
send_one("elevation en cours", fd, s);
event_incant(s, fd, players);
}
else
send_one("ko", fd, s);
free(players);
return (0);
}
/*
* Sends an RC-5 packet, with address "addr", command "cmd" from the led "led"
* led can be CMDLED (front leds) or PROGLED (back led)
*/
void send_packet(unsigned char addr, unsigned char cmd, unsigned char led)
{
static unsigned char toggle_last = 0;
send_one(led);
send_one(led);
if (toggle_last) {
toggle_last = 0;
send_one(led);
} else {
toggle_last = 1;
send_zero(led);
}
unsigned char i;
for (i = 0; i < 5; i++) {
if (addr & _BV(4 - i)) {
send_one(led);
} else {
send_zero(led);
}
}
for (i = 0; i < 6; i++) {
if (cmd & _BV(5 - i)) {
send_one(led);
} else {
send_zero(led);
}
}
ir_off(led);
}
void send_command(int throttle, int leftright, int forwardbackward)
{
send_header();
// TODO: finish...
send_one();
send_one();
send_zero();
send_zero();
//send_zero();
//send_one();
}
int finish_incantation(t_stck *s, int fd)
{
int i;
int *players;
int flag;
int res;
i = -1;
flag = 1;
players = get_players_from_case(s, fd);
res = check_ressource_for_incant(s, fd);
while (players[++i])
flag = s->fds[players[i]].level == s->fds[fd].level ? 1 : 0;
if (flag && (i + 1) == gl_inc_tok[s->fds[fd].level - 1].nb_players && res)
{
upgrade_level(s, fd, players);
event_end_incant(s, fd, players, 1);
players = set_ressources(s, fd, players);
event_end_incant_res(s, players);
}
else
{
send_one("ko", fd, s);
event_end_incant(s, fd, players, 0);
}
free(players);
return (0);
}
void init_graphic(t_stck *s, int fd)
{
t_gparam res;
char *tmp;
memset(&res, 0, sizeof(res));
send_one((tmp = get_msz(s, NULL)), fd, s);
free(tmp);
send_one((tmp = get_sgt(s, NULL)), fd, s);
free(tmp);
res.fd = fd;
get_mct(s, &res);
get_tna(s, &res);
send_players(s, fd);
send_eggs(s, fd);
}
void upgrade_level(t_stck *s, int fd, int *players)
{
char *tmp;
int i;
i = -1;
tmp = Xmalloc(4096 * sizeof(tmp));
s->fds[fd].level++;
sprintf(tmp, "niveau actuel : %d", s->fds[fd].level);
send_one(tmp, fd, s);
while (players[++i])
{
s->fds[players[i]].level++;
send_one(tmp, players[i], s);
}
free(tmp);
}
void
set_freq_sf16fmd2(u_int16_t frequency) {
int c = 0x0f;
u_int16_t freq = (u_int16_t)
((float)frequency*0.7985714+871.28571);
/* Search end - station found */
send_zero(3);
/* Search down */
send_zero(3);
/* Stereo/Forced Mono */
if (stereo)
send_zero(3);
else
send_one(3);
/* FM band */
send_zero(3);
send_zero(3);
/* Band switch */
send_zero(3);
send_zero(3);
/* Locking field strength during search > 30 mkV */
send_one(3);
send_zero(3);
/* Dummy */
send_zero(3);
while (c--)
if (freq & (1 << c))
send_one(2);
else
send_zero(2);
usleep(AFC_DELAY);
return;
}
void
Sink::send_incoming_messages(Multipart& multipart,
bool copy, size_t idx_from, size_t idx_to)
throw(ZmqErrorType)
{
const size_t to = std::min(idx_to, multipart.size());
for (size_t i = idx_from; i < to; ++i)
{
send_one(multipart[i], copy);
}
}
void send_command(int leftright, int forwardbackward, int throttle, int trim)
{
int i;
send_header();
for (i = 7; i >= 0; i--) {
if (leftright & (1 << i)) {
send_one();
} else {
send_zero();
}
}
for (i = 7; i >= 0; i--) {
if (forwardbackward & (1 << i)) {
send_one();
} else {
send_zero();
}
}
for (i = 7; i >= 0; i--) {
if (throttle & (1 << i)) {
send_one();
} else {
send_zero();
}
}
for (i = 7; i >= 0; i--) {
if (trim & (1 << i)) {
send_one();
} else {
send_zero();
}
}
/* there is actually a 1 bit footer */
send_one();
}
int main(int argc, char **argv) {
xbt_os_timer_t timer = xbt_os_timer_new();
/* initialization of SD */
SD_init(&argc, argv);
if (argc > 1) {
SD_create_environment(argv[1]);
} else {
SD_create_environment("../../platforms/One_cluster_no_backbone.xml");
}
ws_list = SD_workstation_get_list();
reclaimed = xbt_dynar_new(sizeof(bcast_task_t),xbt_free_ref);
xbt_dynar_t done = NULL;
xbt_os_cputimer_start(timer);
send_one(0,SD_workstation_get_number());
do {
if (done != NULL && !xbt_dynar_is_empty(done)) {
unsigned int cursor;
SD_task_t task;
xbt_dynar_foreach(done, cursor, task) {
bcast_task_t bt = SD_task_get_data(task);
if (bt->i != bt->j -1)
send_one(bt->i,bt->j);
if (bt->j != bt->k -1)
send_one(bt->j,bt->k);
if (xbt_dynar_length(reclaimed)<100) {
xbt_dynar_push_as(reclaimed,bcast_task_t,bt);
} else {
free(bt);
}
SD_task_destroy(task);
}
xbt_dynar_free(&done);
}
int send_graphic(char *msg, t_stck *s)
{
int i;
i = 0;
while (i < s->lim_fd)
{
if (s->fds[i].type == FD_GRAPH)
send_one(msg, i, s);
i++;
}
return (strlen(msg));
}
void
Outgoing<XRouting>::send_routing(
Part* routing, size_t num) throw (ZmqErrorType)
{
if (routing == 0 || num == 0)
{
ZMQMESSAGE_LOG_STREAM <<
"X route: route is empty, send null message only"
<< ZMQMESSAGE_LOG_TERM;
add_pending_routing_part();
Part part;
send_one(part, false); //empty part
}
else
{
const bool copy = options() & OutOptions::COPY_INCOMING;
for (size_t n = 0; n < num; ++n)
{
add_pending_routing_part();
send_one(routing[n], copy);
}
}
}
int broadcast(t_stck *s, int fd, t_wait *t)
{
char *cmd;
char *tmp;
int k;
int i;
cmd = t->cmd + 10;
i = 3;
tmp = Xmalloc(strlen(cmd) + 32);
while (++i <= s->max_fd)
{
if (s->fds[i].type != FD_IA || i == fd)
continue;
k = get_rep(s, &(s->fds[fd]), &(s->fds[i]));
memset(tmp, 0, strlen(cmd) + 32);
sprintf(tmp, "message %d,%s", k, cmd);
send_one(tmp, i, s);
}
send_one("ok", fd, s);
event_broadcast(s, fd, cmd);
return (0);
}
bool
MavlinkParametersManager::send_params()
{
if (send_uavcan()) {
return true;
} else if (send_one()) {
return true;
} else if (send_untransmitted()) {
return true;
} else {
return false;
}
}
int wait_for_files(FiletransferOptions const *opts)
{
#ifdef linux
DLT_LOG(dltsystem, DLT_LOG_DEBUG, DLT_STRING("dlt-system-filetransfer, waiting for files."));
static char buf[INOTIFY_LEN];
ssize_t len = read(ino.handle, buf, INOTIFY_LEN);
if(len < 0)
{
DLT_LOG(filetransferContext, DLT_LOG_ERROR,
DLT_STRING("Error while waiting for files in dlt-system file transfer."));
return -1;
}
unsigned int i = 0;
while(i < (len-INOTIFY_SZ))
{
struct inotify_event *ie = (struct inotify_event *)&buf[i];
if(ie->len > 0)
{
if((ie->mask & IN_CLOSE_WRITE) || (ie->mask & IN_MOVED_TO))
{
int j;
for(j = 0;j < opts->Count;j++)
{
if(ie->wd == ino.fd[j])
{
DLT_LOG(dltsystem, DLT_LOG_DEBUG, DLT_STRING("dlt-system-filetransfer, found new file."));
int length = strlen(opts->Directory[j])+ie->len+1;
if (length > PATH_MAX)
{
DLT_LOG(filetransferContext, DLT_LOG_ERROR,
DLT_STRING("dlt-system-filetransfer: Very long path for file transfer. Cancelling transfer! Length is: "),DLT_INT(length));
return -1;
}
char *tosend = malloc(length);
snprintf(tosend,length, "%s/%s", opts->Directory[j], ie->name);
send_one(tosend, opts, j);
free(tosend);
}
}
}
}
i += INOTIFY_SZ + ie->len;
}
#endif
return 0;
}
static void send_eggs(t_stck *s, int fd)
{
t_egg *cur;
t_gparam res;
char *tmp;
cur = s->egg;
while (cur)
{
res.e = cur->id;
res.e = cur->x;
res.e = cur->y;
send_one((tmp = get_enw(s, &res)), fd, s);
free(tmp);
cur = cur->next;
}
}
static void send_players(t_stck *s, int fd)
{
t_gparam res;
char *tmp;
int i;
i = 0;
while (i <= s->max_fd)
{
if (s->fds[i].type == FD_IA)
{
res.n = i;
send_one((tmp = get_pnw(s, &res)), fd, s);
free(tmp);
}
i++;
}
}
Sink&
Sink::operator<< (Part& msg)
throw (ZmqErrorType)
{
const bool copy_mode = options_ & OutOptions::COPY_INCOMING;
bool use_copy = false;
if (incoming_)
{
Part* p = std::find(
incoming_->parts(), incoming_->parts() + incoming_->size(), msg);
if (p != incoming_->parts() + incoming_->size())
{
use_copy = copy_mode;
}
}
send_one(msg, use_copy);
return *this;
}
int send_all(t_stck *s, char *msg, int type1, int type2)
{
int res;
int i;
i = 0;
res = 0;
if (!msg)
return (0);
else if (!strlen(msg))
return (0);
while (i < s->lim_fd)
{
if ((s->fds[i]).type == type1 || (s->fds[i]).type == type2)
if (send_one(msg, i, s) > 0)
res++;
i++;
}
return (res);
}
int flush_dir_original(FiletransferOptions const *opts, int which){
struct dirent *dp;
DIR *dir;
const char *sdir = opts->Directory[which];
dir = opendir(sdir);
if(dir != NULL)
{
while((dp = readdir(dir)) != NULL)
{
if(dp->d_type != DT_REG){
//we don't send directories
continue;
}
DLT_LOG(dltsystem, DLT_LOG_DEBUG,
DLT_STRING("dlt-system-filetransfer, old file found in directory."));
int len = strlen(sdir)+strlen(dp->d_name)+2;
char *fn = malloc(len);
MALLOC_ASSERT(fn);
snprintf(fn,len, "%s/%s", sdir, dp->d_name);
if(send_one(fn, opts, which) < 0)
{
closedir(dir);
free(fn);
return -1;
}
free(fn);
}
}
else
{
DLT_LOG(dltsystem, DLT_LOG_ERROR,
DLT_STRING("Could not open directory"),
DLT_STRING(sdir));
return -1;
}
closedir(dir);
return 0;
}
int send_ko(t_stck *s, int fd)
{
return (send_one("ko", fd, s));
}
void
FastTcpAgent::recv(Packet *pkt, Handler *)
{
currentTime_ = fasttime();
hdr_tcp *tcph = hdr_tcp::access(pkt);
hdr_flags *flagh = hdr_flags::access(pkt);
int valid_ack = 0;
if (qs_approved_ == 1 && tcph->seqno() > last_ack_)
endQuickStart();
if (qs_requested_ == 1)
processQuickStart(pkt);
/* W.N.: check if this is from a previous incarnation */
if (tcph->ts() < lastreset_) {
// Remove packet and do nothing
Packet::free(pkt);
return;
}
++nackpack_;
if(firstrecv_<0) { // init fast rtt vars
firstrecv_ = currentTime_;
baseRTT_ = avgRTT_ = rtt_ = firstrecv_;
}
if (flagh->ecnecho())
ecn(tcph->seqno());
int ecnecho = hdr_flags::access(pkt)->ecnecho();
if (ecnecho && ecn_)
ecn(tcph->seqno());
// Check if ACK is valid. Suggestion by Mark Allman.
if (tcph->seqno() >= last_ack_)
valid_ack = 1;
#ifdef FASTTCPAGENT_DEBUG
if (cwnd_ <= 0)
printf("%8.3f : cwnd is not positive! cwnd is %f .\n", (double)currentTime_, (double)cwnd_);
#endif
/*
* If DSACK is being used, check for DSACK blocks here.
* Possibilities: Check for unnecessary Fast Retransmits.
*/
if (!fastrecov_) {
/* normal... not fast recovery */
if ((int)tcph->seqno() > last_ack_) {
if (last_ack_ == 0 ) {
cwnd_ = initial_window();
}
/* check if cwnd has been inflated */
#if 1
if(dupacks_ > numdupacks_ && cwnd_ > newcwnd_) {
//check t_seqno_ before changing cwnd.
if (t_seqno_ < tcph->seqno())
t_seqno_ = tcph->seqno();
//cwnd becomes a negative number in some case.
cwnd_ = t_seqno_ - tcph->seqno() + 1;
dupacks_ = 0;
for (int i=0;i<maxwnd_;i++)
cwnd_array_[i]=cwnd_;
}
#endif
firstpartial_ = 0;
// reset sendtime for acked pkts and incr transmits_
double sendTime = sendtime_[tcph->seqno()%maxwnd_];
double old_pif=cwnd_array_[tcph->seqno()%maxwnd_];
int transmits = transmits_[tcph->seqno()% maxwnd_];
for(int k= (last_natural_ack_number_+1); k<=tcph->seqno(); ++k) {
sendtime_[k%maxwnd_] = -1.0;
transmits_[k%maxwnd_] = 0;
cwnd_array_[k%maxwnd_]=-1;
}
if (t_seqno_ > tcph->seqno()){
if ((transmits == 1) && (currentTime_ - sendTime > 0))
rtt_ = currentTime_ - sendTime;
else
rtt_ = avgRTT_;
}else rtt_ = avgRTT_;
fast_recv_newack_helper(pkt);
timeout_ = FALSE;
scb_->ClearScoreBoard();
fast_est(pkt, rtt_);
fast_cc(rtt_, old_pif);
last_natural_ack_number_ = tcph->seqno();
} else if ((int)tcph->seqno() < last_ack_) {
/*NOTHING*/
//the follows are if (int)tcph->seqno() == last_ack_
} else if (timeout_ == FALSE) {
if (tcph->seqno() != last_ack_) {
fprintf(stderr, "pkt seq %d should be %d\n", tcph->seqno(), last_ack_);
abort();
}
scb_->UpdateScoreBoard (highest_ack_, tcph);
/*
* Check for a duplicate ACK.
* Check that the SACK block actually
* acknowledges new data.
*/
if(scb_->CheckUpdate()) {
if (++dupacks_ == numdupacks(cwnd_)) {
/*
* Assume we dropped just one packet.
* Retransmit last ack + 1
* and try to resume the sequence.
*/
dupack_action();
} else if (dupacks_ < numdupacks(cwnd_) && singledup_ ) {
send_one();
}
}
}
if (valid_ack || aggressive_maxburst_)
if (dupacks_ == 0)
send_much(FALSE, 0, maxburst_);
} else {
/* we are in fast recovery */
cwnd_update_time = currentTime_;
--pipe_;
if ((int)tcph->seqno() >= recover_) {
/* ACK indicates fast recovery is over */
recover_ = 0;
fastrecov_ = FALSE;
newack(pkt);
/* if the connection is done, call finish() */
if ((highest_ack_ >= curseq_-1) && !closed_) {
closed_ = 1;
finish();
}
timeout_ = FALSE;
scb_->ClearScoreBoard();
/* New window: W/2 - K or W/2? */
} else if ((int)tcph->seqno() > highest_ack_) {
/* Not out of fast recovery yet.
* Update highest_ack_, but not last_ack_. */
highest_ack_ = (int)tcph->seqno();
scb_->UpdateScoreBoard (highest_ack_, tcph);
if (partial_ack_) {
/* partial_ack_ is needed to guarantee that */
/* a new packet is sent in response to a */
/* partial ack. */
partial_ack_action();
++pipe_;
if (firstpartial_ == 0) {
newtimer(pkt);
t_backoff_ = 1;
firstpartial_ = 1;
}
} else {
--pipe_;
newtimer(pkt);
t_backoff_ = 1;
/* If this partial ACK is from a retransmitted pkt,*/
/* then we decrement pipe_ again, so that we never */
/* do worse than slow-start. If this partial ACK */
/* was instead from the original packet, reordered,*/
/* then this might be too aggressive. */
}
} else if (timeout_ == FALSE) {
/* got another dup ack */
scb_->UpdateScoreBoard (highest_ack_, tcph);
if(scb_->CheckUpdate()) {
if (dupacks_ > 0)
dupacks_++;
}
}
if (valid_ack || aggressive_maxburst_)
send_much(FALSE, 0, maxburst_);
}
Packet::free(pkt);
}
