int app_rtsp_server_set_global_info(rtsp_server_config *config, rtsp_server_config *newconfig)
{
if(g_rtsp_shandle == NULL) {
PRINTF("\n");
return -1;
}
rtsp_ginfo_print(config);
int need_save = 0;
mid_mutex_lock(g_rtsp_shandle->mutex);
rtsp_server_config *old = &(g_rtsp_shandle->rtsp_config);
/*rtsp listen port*/
if((config->s_port != old->s_port) && (config->s_port >= 81 && config->s_port <= 65535)) {
old->s_port = config->s_port;
need_save = 1;
}
/*rtsp active time 10-900000*/
if(config->active != old->active) {
if(config->active >= 10 && config->active <= 900000) {
old->active = config->active;
need_save = 1;
//set rtsp lib the active
rtsp_set_keepactive_time(g_rtsp_shandle->rtsp_config.active);
}
}
//mtu 228--1500
if(config->s_mtu != old->s_mtu) {
if(config->s_mtu >= 228 && config->s_mtu <= 1500) {
old->s_mtu = config->s_mtu ;
need_save = 1;
}
}
if(config->mult_flag == 0 || config->mult_flag == 1) {
if(config->mult_flag != old->mult_flag) {
//multicast
if(config->mult_flag == 1) {
old->mult_flag = config->mult_flag;
strcpy(old->mult_ip, config->mult_ip);
old->mult_port = config->mult_port;
need_save = 1;
} else {
old->mult_flag = config->mult_flag;
need_save = 1;
}
} else if((config->mult_flag == old->mult_flag) && (config->mult_flag == 1)) {
if(strcmp(old->mult_ip, config->mult_ip) != 0 || old->mult_port != config->mult_port) {
strcpy(old->mult_ip, config->mult_ip);
old->mult_port = config->mult_port;
need_save = 1;
}
}
}
//save flash
if(need_save == 1) {
app_rtsp_global_config_fwrite(old);
}
mid_mutex_unlock(g_rtsp_shandle->mutex);
return 0;
}
/*
* cmyth_livetv_chain_seek(cmyth_recorder_t file, long long offset, int whence)
*
* Scope: PUBLIC
*
* Description
*
* Seek to a new position in the file based on the value of whence:
* SEEK_SET
* The offset is set to offset bytes.
* SEEK_CUR
* The offset is set to the current position plus offset bytes.
* SEEK_END
* The offset is set to the size of the file minus offset bytes.
*
* Return Value:
*
* Sucess: 0
*
* Failure: an int containing -errno
*/
static long long
cmyth_livetv_chain_seek(cmyth_recorder_t rec, long long offset, int whence)
{
long long ret;
cmyth_file_t fp;
int cur, ct;
if (rec == NULL)
return -EINVAL;
ct = rec->rec_livetv_chain->chain_ct;
if (whence == SEEK_END) {
offset -= rec->rec_livetv_file->file_req;
for (cur = rec->rec_livetv_chain->chain_current; cur < ct; cur++) {
offset += rec->rec_livetv_chain->chain_files[cur]->file_length;
}
cur = rec->rec_livetv_chain->chain_current;
fp = rec->rec_livetv_chain->chain_files[cur];
whence = SEEK_CUR;
}
if (whence == SEEK_SET) {
for (cur = 0; cur < ct; cur++) {
fp = rec->rec_livetv_chain->chain_files[cur];
if (offset < (long long)fp->file_length)
break;
offset -= fp->file_length;
}
}
if (whence == SEEK_CUR) {
if (offset == 0) {
cur = rec->rec_livetv_chain->chain_current;
offset += rec->rec_livetv_chain->chain_files[cur]->file_req;
for (; cur > 0; cur--) {
offset += rec->rec_livetv_chain->chain_files[cur-1]->file_length;
}
return offset;
}
else
{
cur = rec->rec_livetv_chain->chain_current;
fp = rec->rec_livetv_chain->chain_files[cur];
}
offset += fp->file_req;
while (offset > (long long)fp->file_length) {
cur++;
offset -= fp->file_length;
if(cur == ct)
return -1;
fp = rec->rec_livetv_chain->chain_files[cur];
}
while (offset < 0) {
cur--;
if(cur < 0)
return -1;
fp = rec->rec_livetv_chain->chain_files[cur];
offset += fp->file_length;
}
offset -= fp->file_req;
}
pthread_mutex_lock(&mutex);
ret = cmyth_file_seek_unlocked(fp, offset, whence);
PRINTF("** SSDEBUG: new pos %lld after seek command\n", ret);
cur -= rec->rec_livetv_chain->chain_current;
if (ret >= 0 && cur) {
cmyth_livetv_chain_switch(rec, cur);
}
pthread_mutex_unlock(&mutex);
return ret;
}
void printInt16(char* ptr) {
PRINTF("%d", *((uint16_t*)ptr));
}
/*---------------------------------------------------------------------------*/
static void
update_rtmetric(struct collect_conn *tc)
{
struct neighbor *n;
/* We should only update the rtmetric if we are not the sink. */
if(tc->rtmetric != SINK) {
/* Find the neighbor with the lowest rtmetric. */
n = neighbor_best();
/* If n is NULL, we have no best neighbor. */
if(n == NULL) {
/* If we have don't have any neighbors, we set our rtmetric to
the maximum value to indicate that we do not have a route. */
if(tc->rtmetric != RTMETRIC_MAX) {
PRINTF("%d.%d: didn't find a best neighbor, setting rtmetric to max\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
}
tc->rtmetric = RTMETRIC_MAX;
announcement_set_value(&tc->announcement, tc->rtmetric);
} else {
/* We set our rtmetric to the rtmetric of our best neighbor plus
the expected transmissions to reach that neighbor. */
if(n->rtmetric + neighbor_etx(n) != tc->rtmetric) {
uint16_t old_rtmetric = tc->rtmetric;
tc->rtmetric = n->rtmetric + neighbor_etx(n);
#if !COLLECT_ANNOUNCEMENTS
neighbor_discovery_start(&tc->neighbor_discovery_conn, tc->rtmetric);
#else
announcement_set_value(&tc->announcement, tc->rtmetric);
#endif /* !COLLECT_ANNOUNCEMENTS */
PRINTF("%d.%d: new rtmetric %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
tc->rtmetric);
/* We got a new, working, route we send any queued packets we may have. */
if(old_rtmetric == RTMETRIC_MAX) {
send_queued_packet();
}
}
}
}
/* DEBUG_PRINTF("%d: new rtmetric %d\n", node_id, rtmetric);*/
#if CONTIKI_TARGET_NETSIM
{
char buf[8];
if(tc->rtmetric == RTMETRIC_MAX) {
strcpy(buf, " ");
} else {
sprintf(buf, "%.1f", (float)tc->rtmetric / NEIGHBOR_ETX_SCALE);
}
ether_set_text(buf);
}
#endif
}
void configure_request(xcb_generic_event_t *evt)
{
xcb_configure_request_event_t *e = (xcb_configure_request_event_t *) evt;
PRINTF("configure request %X\n", e->window);
coordinates_t loc;
bool is_managed = locate_window(e->window, &loc);
client_t *c = (is_managed ? loc.node->client : NULL);
int w = 0, h = 0;
if (is_managed && !is_floating(c)) {
if (e->value_mask & XCB_CONFIG_WINDOW_X)
c->floating_rectangle.x = e->x;
if (e->value_mask & XCB_CONFIG_WINDOW_Y)
c->floating_rectangle.y = e->y;
if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH)
w = e->width;
if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT)
h = e->height;
if (w != 0) {
restrain_floating_width(c, &w);
c->floating_rectangle.width = w;
}
if (h != 0) {
restrain_floating_height(c, &h);
c->floating_rectangle.height = h;
}
xcb_configure_notify_event_t evt;
xcb_rectangle_t rect;
xcb_window_t win = c->window;
unsigned int bw = c->border_width;
if (c->fullscreen)
rect = loc.monitor->rectangle;
else
rect = c->tiled_rectangle;
evt.response_type = XCB_CONFIGURE_NOTIFY;
evt.event = win;
evt.window = win;
evt.above_sibling = XCB_NONE;
evt.x = rect.x;
evt.y = rect.y;
evt.width = rect.width;
evt.height = rect.height;
evt.border_width = bw;
evt.override_redirect = false;
xcb_send_event(dpy, false, win, XCB_EVENT_MASK_STRUCTURE_NOTIFY, (const char *) &evt);
if (c->pseudo_tiled)
arrange(loc.monitor, loc.desktop);
} else {
uint16_t mask = 0;
uint32_t values[7];
unsigned short i = 0;
if (e->value_mask & XCB_CONFIG_WINDOW_X) {
mask |= XCB_CONFIG_WINDOW_X;
values[i++] = e->x;
if (is_managed)
c->floating_rectangle.x = e->x;
}
if (e->value_mask & XCB_CONFIG_WINDOW_Y) {
mask |= XCB_CONFIG_WINDOW_Y;
values[i++] = e->y;
if (is_managed)
c->floating_rectangle.y = e->y;
}
if (e->value_mask & XCB_CONFIG_WINDOW_WIDTH) {
mask |= XCB_CONFIG_WINDOW_WIDTH;
w = e->width;
if (is_managed) {
restrain_floating_width(c, &w);
c->floating_rectangle.width = w;
}
values[i++] = w;
}
if (e->value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
mask |= XCB_CONFIG_WINDOW_HEIGHT;
h = e->height;
if (is_managed) {
restrain_floating_height(c, &h);
c->floating_rectangle.height = h;
}
values[i++] = h;
}
if (!is_managed && e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
mask |= XCB_CONFIG_WINDOW_BORDER_WIDTH;
values[i++] = e->border_width;
}
if (e->value_mask & XCB_CONFIG_WINDOW_SIBLING) {
mask |= XCB_CONFIG_WINDOW_SIBLING;
values[i++] = e->sibling;
}
if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE) {
mask |= XCB_CONFIG_WINDOW_STACK_MODE;
values[i++] = e->stack_mode;
}
xcb_configure_window(dpy, e->window, mask, values);
}
if (is_managed)
translate_client(monitor_from_client(c), loc.monitor, c);
}
/*---------------------------------------------------------------------------*/
static void
handle_data(struct rudolph1mh_conn *c, struct rudolph1mh_datapacket *p)
{
//Only called if partner is correct of NULL
PRINTF("Handle P: %d:%d - %d\n",
c->partner.u8[0], c->partner.u8[1], p->h.chunk);
if(p->h.chunk == 0) { //New stream
PRINTF("%d.%d: rudolph1mh new v_id %d, chunk %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.s_id, p->h.chunk);
c->s_id = p->h.s_id;
c->highest_chunk = c->chunk = 0;
if(p->h.chunk != 0) {
send_nack(c);
}
else {
if(!c->cb->write_chunk){
printf("No write-callback\n");
return;
}
c->cb->write_chunk(c, 0, RUDOLPH1MH_FLAG_NEWFILE, p->data, 0);
write_data(c, 0, p->data, p->datalen);
c->chunk = 1; /* Next chunk is 1. */
//ctimer_set(&c->t, send_interval * 30, send_next_packet, c);
}
/* }*/
}
else if(p->h.s_id == c->s_id) {
PRINTF("%d.%d: got chunk %d (%d) highest heard %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk, c->chunk, c->highest_chunk);
if(p->h.chunk == c->chunk) {
PRINTF("%d.%d: received chunk %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk);
write_data(c, p->h.chunk, p->data, p->datalen);
if(c->highest_chunk < c->chunk) {
c->highest_chunk = c->chunk;
}
c->chunk++;
}
else if(p->h.chunk > c->chunk) {
PRINTF("%d.%d: received chunk %d > %d, sending NACK\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk, c->chunk);
send_nack(c);
c->highest_chunk = p->h.chunk;
}
else if(p->h.chunk < c->chunk) {
/* Ignore packets with a lower chunk number */
}
/* If we have heard a higher chunk number, we send a NACK so that
we get a repair for the next packet. */
if(c->highest_chunk > p->h.chunk) {
send_nack(c);
}
}
else { /* p->h.s_id < c->current.h.s_id */
PRINTF("%d.%d: Recieved s_id %i expected %i\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.s_id, c->s_id);
/* Ignore packets with old s_id */
}
}
/*---------------------------------------------------------------------------*/
static void
timeout_mesh(struct mesh_conn *mesh)
{
PRINTF("%d.%d: dropped ipolite\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
}
static int app_rtsp_config_fread(RTSP_Output_Server_Handle *handle)
{
char temp[512] = {0};
int ret = -1 ;
int value = 0;
char config_file[256] = {0};
strcpy(config_file, RTSP_SERVER_CONFIG_INI);
ret = app_ini_read_int(config_file, "rtsp", "used", &value);
if(ret == -1 || value == NOTUSED) {
PRINTF("warning ,the rtsp is not used\n");
return -1;
}
handle->s_used = value;
if(app_ini_read_int(config_file, "rtsp", "status", &value) != -1) {
handle->config.status = value;
}
if(app_ini_read_int(config_file, "rtsp", "type", &value) != -1) {
if(value == TYPE_RTSP) {
handle->config.type = value;
} else {
handle->config.type = TYPE_RTSP;
}
}
if(app_ini_read_string(config_file, "rtsp", "main_ip", temp, sizeof(temp)) != -1) {
strcpy(handle->config.main_ip, temp);
}
if(app_ini_read_int(config_file, "rtsp", "video_port", &value) != -1) {
handle->config.video_port = value;
}
if(app_ini_read_int(config_file, "rtsp", "audio_port", &value) != -1) {
handle->config.audio_port = value;
}
if(app_ini_read_int(config_file, "rtsp", "mtu", &value) != -1) {
if(value > 228 || value < 1500) {
handle->config.mtu = value;
} else {
handle->config.mtu = 1500;
}
}
if(app_ini_read_int(config_file, "rtsp", "ttl", &value) != -1) {
handle->config.ttl = value;
}
if(app_ini_read_int(config_file, "rtsp", "tos", &value) != -1) {
handle->config.tos = value;
}
// if(app_ini_read_int(config_file, "rtsp", "active", &value) != -1) {
// handle->config.active = value;
// }
if(app_ini_read_int(config_file, "rtsp", "tc", &value) != -1) {
handle->config.tc_flag = value;
}
if(app_ini_read_int(config_file, "rtsp", "tc_rate", &value) != -1) {
handle->config.tc_rate = value;
}
//check config
//set config
return 0;
}
/*---------------------------------------------------------------------------*/
static int
send_packet(void)
{
rtimer_clock_t t0;
rtimer_clock_t t;
rtimer_clock_t encounter_time = 0;
int strobes;
int ret;
#if 0
struct xmac_hdr *hdr;
#endif
uint8_t got_strobe_ack = 0;
uint8_t got_ack = 0;
uint8_t strobe[MAX_STROBE_SIZE];
int strobe_len, len;
int is_broadcast = 0;
/*int is_reliable; */
struct encounter *e;
struct queuebuf *packet;
int is_already_streaming = 0;
uint8_t collisions;
/* Create the X-MAC header for the data packet. */
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), &rimeaddr_null)) {
is_broadcast = 1;
PRINTDEBUG("xmac: send broadcast\n");
} else {
#if UIP_CONF_IPV6
PRINTDEBUG("xmac: send unicast to %02x%02x:%02x%02x:%02x%02x:%02x%02x\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[2],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[3],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[4],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[5],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[6],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[7]);
#else
PRINTDEBUG("xmac: send unicast to %u.%u\n",
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_RECEIVER)->u8[1]);
#endif /* UIP_CONF_IPV6 */
}
/* is_reliable = packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE); */
packetbuf_set_attr(PACKETBUF_ATTR_MAC_ACK, 1);
len = NETSTACK_FRAMER.create();
strobe_len = len + sizeof(struct xmac_hdr);
if(len < 0 || strobe_len > (int)sizeof(strobe)) {
/* Failed to send */
PRINTF("xmac: send failed, too large header\n");
return MAC_TX_ERR_FATAL;
}
memcpy(strobe, packetbuf_hdrptr(), len);
strobe[len] = DISPATCH; /* dispatch */
strobe[len + 1] = TYPE_STROBE; /* type */
packetbuf_compact();
packet = queuebuf_new_from_packetbuf();
if(packet == NULL) {
/* No buffer available */
PRINTF("xmac: send failed, no queue buffer available (of %u)\n",
QUEUEBUF_CONF_NUM);
return MAC_TX_ERR;
}
#if WITH_STREAMING
if(is_streaming == 1 &&
(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&is_streaming_to) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&is_streaming_to_too))) {
is_already_streaming = 1;
}
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM) {
is_streaming = 1;
if(rimeaddr_cmp(&is_streaming_to, &rimeaddr_null)) {
rimeaddr_copy(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
} else if(!rimeaddr_cmp(&is_streaming_to, packetbuf_addr(PACKETBUF_ADDR_RECEIVER))) {
rimeaddr_copy(&is_streaming_to_too, packetbuf_addr(PACKETBUF_ADDR_RECEIVER));
}
stream_until = RTIMER_NOW() + DEFAULT_STREAM_TIME;
}
#endif /* WITH_STREAMING */
off();
#if WITH_ENCOUNTER_OPTIMIZATION
/* We go through the list of encounters to find if we have recorded
an encounter with this particular neighbor. If so, we can compute
the time for the next expected encounter and setup a ctimer to
switch on the radio just before the encounter. */
for(e = list_head(encounter_list); e != NULL; e = list_item_next(e)) {
const rimeaddr_t *neighbor = packetbuf_addr(PACKETBUF_ADDR_RECEIVER);
if(rimeaddr_cmp(neighbor, &e->neighbor)) {
rtimer_clock_t wait, now, expected;
/* We expect encounters to happen every DEFAULT_PERIOD time
units. The next expected encounter is at time e->time +
DEFAULT_PERIOD. To compute a relative offset, we subtract
with clock_time(). Because we are only interested in turning
on the radio within the DEFAULT_PERIOD period, we compute the
waiting time with modulo DEFAULT_PERIOD. */
now = RTIMER_NOW();
wait = ((rtimer_clock_t)(e->time - now)) % (DEFAULT_PERIOD);
if(wait < 2 * DEFAULT_ON_TIME) {
wait = DEFAULT_PERIOD;
}
expected = now + wait - 2 * DEFAULT_ON_TIME;
#if WITH_ACK_OPTIMIZATION
/* Wait until the receiver is expected to be awake */
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) !=
PACKETBUF_ATTR_PACKET_TYPE_ACK &&
is_streaming == 0) {
/* Do not wait if we are sending an ACK, because then the
receiver will already be awake. */
while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected));
}
#else /* WITH_ACK_OPTIMIZATION */
/* Wait until the receiver is expected to be awake */
while(RTIMER_CLOCK_LT(RTIMER_NOW(), expected));
#endif /* WITH_ACK_OPTIMIZATION */
}
}
#endif /* WITH_ENCOUNTER_OPTIMIZATION */
/* By setting we_are_sending to one, we ensure that the rtimer
powercycle interrupt do not interfere with us sending the packet. */
we_are_sending = 1;
t0 = RTIMER_NOW();
strobes = 0;
LEDS_ON(LEDS_BLUE);
/* Send a train of strobes until the receiver answers with an ACK. */
/* Turn on the radio to listen for the strobe ACK. */
// on();
collisions = 0;
if(!is_already_streaming) {
watchdog_stop();
got_strobe_ack = 0;
t = RTIMER_NOW();
for(strobes = 0, collisions = 0;
got_strobe_ack == 0 && collisions == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t0 + xmac_config.strobe_time);
strobes++) {
while(got_strobe_ack == 0 &&
RTIMER_CLOCK_LT(RTIMER_NOW(), t + xmac_config.strobe_wait_time)) {
#if 0
rtimer_clock_t now = RTIMER_NOW();
/* See if we got an ACK */
packetbuf_clear();
len = NETSTACK_RADIO.read(packetbuf_dataptr(), PACKETBUF_SIZE);
if(len > 0) {
packetbuf_set_datalen(len);
if(NETSTACK_FRAMER.parse() >= 0) {
hdr = packetbuf_dataptr();
if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE_ACK) {
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* We got an ACK from the receiver, so we can immediately send
the packet. */
got_strobe_ack = 1;
encounter_time = now;
} else {
PRINTDEBUG("xmac: strobe ack for someone else\n");
}
} else /*if(hdr->dispatch == DISPATCH && hdr->type == TYPE_STROBE)*/ {
PRINTDEBUG("xmac: strobe from someone else\n");
collisions++;
}
} else {
PRINTF("xmac: send failed to parse %u\n", len);
}
}
#endif /* 0 */
}
t = RTIMER_NOW();
/* Send the strobe packet. */
if(got_strobe_ack == 0 && collisions == 0) {
if(is_broadcast) {
#if WITH_STROBE_BROADCAST
ret = NETSTACK_RADIO.send(strobe, strobe_len);
#else
/* restore the packet to send */
queuebuf_to_packetbuf(packet);
ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
#endif
off();
} else {
#if 0
rtimer_clock_t wt;
#endif
on();
ret = NETSTACK_RADIO.send(strobe, strobe_len);
#if 0
/* Turn off the radio for a while to let the other side
respond. We don't need to keep our radio on when we know
that the other side needs some time to produce a reply. */
off();
wt = RTIMER_NOW();
while(RTIMER_CLOCK_LT(RTIMER_NOW(), wt + WAIT_TIME_BEFORE_STROBE_ACK));
#endif /* 0 */
#if RDC_CONF_HARDWARE_ACK
if(ret == RADIO_TX_OK) {
got_strobe_ack = 1;
} else {
off();
}
#else
if(detect_ack()) {
got_strobe_ack = 1;
} else {
off();
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
}
}
#if WITH_ACK_OPTIMIZATION
/* If we have received the strobe ACK, and we are sending a packet
that will need an upper layer ACK (as signified by the
PACKETBUF_ATTR_RELIABLE packet attribute), we keep the radio on. */
if(got_strobe_ack && (packetbuf_attr(PACKETBUF_ATTR_RELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_ERELIABLE) ||
packetbuf_attr(PACKETBUF_ATTR_PACKET_TYPE) ==
PACKETBUF_ATTR_PACKET_TYPE_STREAM)) {
on(); /* Wait for ACK packet */
waiting_for_packet = 1;
} else {
off();
}
#endif /* WITH_ACK_OPTIMIZATION */
/* restore the packet to send */
queuebuf_to_packetbuf(packet);
queuebuf_free(packet);
/* Send the data packet. */
if((is_broadcast || got_strobe_ack || is_streaming) && collisions == 0) {
ret = NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
if(!is_broadcast) {
#if RDC_CONF_HARDWARE_ACK
if(ret == RADIO_TX_OK) {
got_ack = 1;
}
#else
if(detect_ack()) {
got_ack = 1;
}
#endif /* RDC_CONF_HARDWARE_ACK */
}
}
off();
#if WITH_ENCOUNTER_OPTIMIZATION
if(got_strobe_ack && !is_streaming) {
register_encounter(packetbuf_addr(PACKETBUF_ADDR_RECEIVER), encounter_time);
}
#endif /* WITH_ENCOUNTER_OPTIMIZATION */
watchdog_start();
PRINTF("xmac: send (strobes=%u,len=%u,%s), done\n", strobes,
packetbuf_totlen(), got_strobe_ack ? "ack" : "no ack");
#if XMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet transmission. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the transmitted
packet to packet attributes so that the higher levels can keep
track of the amount of energy spent on transmitting the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready for
the next packet. */
compower_clear(¤t_packet);
#endif /* XMAC_CONF_COMPOWER */
we_are_sending = 0;
LEDS_OFF(LEDS_BLUE);
if(collisions == 0) {
if(is_broadcast == 0 && got_ack == 0) {
return MAC_TX_NOACK;
} else {
return MAC_TX_OK;
}
} else {
someone_is_sending++;
return MAC_TX_COLLISION;
}
}
static int app_rtsp_global_config_fwrite(rtsp_server_config *config)
{
if(config == NULL) {
ERR_PRN("\n");
return -1;
}
int ret = 0;
char bak_name[512] = {0};
char cmd[512] = {0};
int value = 0;
// int used = 0;
sprintf(bak_name, "%s.bak", RTSP_SERVER_GLOBAL_CONFIG_INI);
value = config->s_port;
ret = app_ini_write_int(bak_name, "rtsp_config", "s_port", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config->active;
ret = app_ini_write_int(bak_name, "rtsp_config", "active", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config->s_mtu;
ret = app_ini_write_int(bak_name, "rtsp_config", "s_mtu", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config->mult_flag;
ret = app_ini_write_int(bak_name, "rtsp_config", "mult_flag", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
ret = app_ini_write_string(bak_name, "rtsp_config", "mult_ip", config->mult_ip);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config->mult_port;
ret = app_ini_write_int(bak_name, "rtsp_config", "mult_port", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
/*拷贝bak文件到ini*/
sprintf(cmd, "cp -rf %s %s;rm -rf %s", bak_name, RTSP_SERVER_GLOBAL_CONFIG_INI, bak_name);
system(cmd);
PRINTF("i will run cmd:%s\n", cmd);
return 0;
}
static int app_rtsp_config_fwrite(int reset)
{
if(g_rtsp_shandle == NULL) {
ERR_PRN("\n");
return -1;
}
// int total = 0;
int ret = 0;
//int value = 0;
// int i = 0;
char bak_name[512] = {0};
// char section[256] = {0};
char cmd[512] = {0};
int value = 0;
int used = 0;
sprintf(bak_name, "%s.bak", RTSP_SERVER_CONFIG_INI);
stream_output_server_config config ;
mid_mutex_lock(g_rtsp_shandle->mutex);
config = g_rtsp_shandle->config;
used = g_rtsp_shandle->s_used;
mid_mutex_unlock(g_rtsp_shandle->mutex);
/*写接口到bak文件*/
value = config.tc_flag;
ret = app_ini_write_int(bak_name, "rtsp", "tc", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
// value = config.active;
// ret = app_ini_write_int(bak_name, "rtsp", "active", value);
// if(ret == -1) {
// ERR_PRN("\n");
// return -1;
// }
value = config.tos;
ret = app_ini_write_int(bak_name, "rtsp", "tos", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.ttl;
ret = app_ini_write_int(bak_name, "rtsp", "ttl", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.mtu;
ret = app_ini_write_int(bak_name, "rtsp", "mtu", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.audio_port;
ret = app_ini_write_int(bak_name, "rtsp", "audio_port", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.video_port;
ret = app_ini_write_int(bak_name, "rtsp", "video_port", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
//ip
ret = app_ini_write_string(bak_name, "rtsp", "main_ip", config.main_ip);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.type;
ret = app_ini_write_int(bak_name, "rtsp", "type", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.status;
ret = app_ini_write_int(bak_name, "rtsp", "status", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = used;
if(reset == 1) {
value = 0;
}
ret = app_ini_write_int(bak_name, "rtsp", "used", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
value = config.tc_rate;
ret = app_ini_write_int(bak_name, "rtsp", "tc_rate", value);
if(ret == -1) {
ERR_PRN("\n");
return -1;
}
/*拷贝bak文件到ini*/
if(ret != -1) {
sprintf(cmd, "cp -rf %s %s;rm -rf %s", bak_name, RTSP_SERVER_CONFIG_INI, bak_name);
system(cmd);
PRINTF("i will run cmd:%s\n", cmd);
}
/*拷贝bak文件到ini*/
return ret;
}
/*==============================================================================
Function: <rtsp_porting_client_add>
Input:
Output:
Description: 用于rtsp线程调用，建立一个新的client
Modify:
Auth: zhangmin
Date: 2012.04.04
==============================================================================*/
static int rtsp_porting_client_add(char *ip, int vport, int aport, int type)
{
if(g_rtsp_shandle == NULL) {
PRINTF("Error\n");
return -1;
}
// int ret = -1;
int r_num = -1;
int free_num = -1;
struct sockaddr_in video_addr;
struct sockaddr_in audio_addr;
int have_audio = 0;
mid_mutex_lock(g_rtsp_shandle->mutex);
r_num = rtsp_client_find(ip, vport, aport, type, g_rtsp_shandle, &free_num);
if(r_num >= 0) {
PRINTF("Warnning,the client %s:%d is repeat %d client\n", ip, vport, r_num);
if(mid_ip_is_multicast(ip) == 1) {
g_rtsp_shandle->client[r_num].usenum ++;
PRINTF("Debug,the %d client is multicast,the usenum=%d\n", r_num, g_rtsp_shandle->client[r_num].usenum);
mid_mutex_unlock(g_rtsp_shandle->mutex);
return 0;
}
}
if(free_num == -1) {
PRINTF("Warnning,there is not have free client\n");
mid_mutex_unlock(g_rtsp_shandle->mutex);
return -1;
}
memset(&video_addr, 0, sizeof(struct sockaddr_in));
memset(&audio_addr, 0, sizeof(struct sockaddr_in));
if(aport != 0) {
have_audio = 1;
}
inet_pton(AF_INET, ip, &video_addr.sin_addr);
video_addr.sin_port = htons(vport);
video_addr.sin_family = AF_INET;
if(have_audio) {
inet_pton(AF_INET, ip, &audio_addr.sin_addr);
audio_addr.sin_port = htons(aport);
audio_addr.sin_family = AF_INET;
}
//create new client
PRINTF("Debug,the %d client will create for the %s:%d-%d\n", free_num, ip, vport, aport);
rtsp_client_create(&video_addr, &audio_addr, type, &(g_rtsp_shandle->client[free_num]));
if(mid_ip_is_multicast(ip) == 1) {
g_rtsp_shandle->client[free_num].usenum ++;
PRINTF("Debug,the %d client is multicast,the usenum=%d\n", free_num, g_rtsp_shandle->client[free_num].usenum);
}
//config the client
rtsp_client_config(&(g_rtsp_shandle->client[free_num]), &(g_rtsp_shandle->config));
//set tc ip ,port
mid_mutex_unlock(g_rtsp_shandle->mutex);
return 0;
}
int stream_rtsp_del_client_tc(int num)
{
PRINTF("tc num = %d\n", num);
tc_del_element(num);
return 0;
}
//不对状态进行操作
int app_rtsp_server_set_common_info(stream_output_server_config *in, stream_output_server_config *out)
{
if(in == NULL || out == NULL) {
PRINTF("Error.\n");
return -1;
}
int tc_change = 0;
int ttl_change = 0;
if(g_rtsp_shandle == NULL) {
PRINTF("\n");
return -1;
}
mid_mutex_lock(g_rtsp_shandle->mutex);
if(in->mtu >= 228 && in->mtu <= 1500) {
g_rtsp_shandle->config.mtu = in->mtu;
PRINTF("set mtu=%d\n", in->mtu);
}
if(in->ttl >= 1 && in->ttl <= 255) {
g_rtsp_shandle->config.ttl = in->ttl;
PRINTF("set ttl=%d\n", in->ttl);
ttl_change = 2;
}
if(in->tos >= 0 && in->tos <= 255) {
g_rtsp_shandle->config.tos = in->tos;
PRINTF("set tos=%d\n", in->tos);
ttl_change = 2;
}
if(in->tc_flag != g_rtsp_shandle->config.tc_flag) {
tc_change = 1;
g_rtsp_shandle->config.tc_flag = in->tc_flag;
PRINTF("tc_flag change to %d\n", in->tc_flag);
}
if(in->tc_rate != g_rtsp_shandle->config.tc_rate) {
tc_change = 1;
g_rtsp_shandle->config.tc_rate = in->tc_rate;
PRINTF("tc_rate change to %d\n", in->tc_rate);
}
mid_mutex_unlock(g_rtsp_shandle->mutex);
//add code for tc by zm
if(tc_change == 1) {
stream_rtsp_set_all_tc();
}
if(ttl_change == 2) {
stream_rtsp_set_all_config();
}
app_rtsp_config_fwrite(0);
return 0;
}
static void
my_closedir (void *dir)
{
PRINTF ("my_closedir ()\n");
free (dir);
}
/*---------------------------------------------------------------------------*/
static void
input_packet(void)
{
struct xmac_hdr *hdr;
if(NETSTACK_FRAMER.parse() >= 0) {
hdr = packetbuf_dataptr();
if(hdr->dispatch != DISPATCH) {
someone_is_sending = 0;
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr) ||
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null)) {
/* This is a regular packet that is destined to us or to the
broadcast address. */
/* We have received the final packet, so we can go back to being
asleep. */
off();
/* Check for duplicate packet by comparing the sequence number
of the incoming packet with the last few ones we saw. */
{
int i;
for(i = 0; i < MAX_SEQNOS; ++i) {
if(packetbuf_attr(PACKETBUF_ATTR_PACKET_ID) == received_seqnos[i].seqno &&
rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_SENDER),
&received_seqnos[i].sender)) {
/* Drop the packet. */
return;
}
}
for(i = MAX_SEQNOS - 1; i > 0; --i) {
memcpy(&received_seqnos[i], &received_seqnos[i - 1],
sizeof(struct seqno));
}
received_seqnos[0].seqno = packetbuf_attr(PACKETBUF_ATTR_PACKET_ID);
rimeaddr_copy(&received_seqnos[0].sender,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
}
#if XMAC_CONF_COMPOWER
/* Accumulate the power consumption for the packet reception. */
compower_accumulate(¤t_packet);
/* Convert the accumulated power consumption for the received
packet to packet attributes so that the higher levels can
keep track of the amount of energy spent on receiving the
packet. */
compower_attrconv(¤t_packet);
/* Clear the accumulated power consumption so that it is ready
for the next packet. */
compower_clear(¤t_packet);
#endif /* XMAC_CONF_COMPOWER */
waiting_for_packet = 0;
PRINTDEBUG("xmac: data(%u)\n", packetbuf_datalen());
NETSTACK_MAC.input();
return;
} else {
PRINTDEBUG("xmac: data not for us\n");
}
} else if(hdr->type == TYPE_STROBE) {
someone_is_sending = 2;
if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_node_addr)) {
/* This is a strobe packet for us. */
/* If the sender address is someone else, we should
acknowledge the strobe and wait for the packet. By using
the same address as both sender and receiver, we flag the
message is a strobe ack. */
waiting_for_packet = 1;
#if 0
hdr->type = TYPE_STROBE_ACK;
packetbuf_set_addr(PACKETBUF_ADDR_RECEIVER,
packetbuf_addr(PACKETBUF_ADDR_SENDER));
packetbuf_set_addr(PACKETBUF_ADDR_SENDER, &rimeaddr_node_addr);
packetbuf_compact();
if(NETSTACK_FRAMER.create() >= 0) {
/* We turn on the radio in anticipation of the incoming
packet. */
someone_is_sending = 1;
waiting_for_packet = 1;
on();
NETSTACK_RADIO.send(packetbuf_hdrptr(), packetbuf_totlen());
PRINTDEBUG("xmac: send strobe ack %u\n", packetbuf_totlen());
} else {
PRINTF("xmac: failed to send strobe ack\n");
}
#endif /* 0 */
} else if(rimeaddr_cmp(packetbuf_addr(PACKETBUF_ADDR_RECEIVER),
&rimeaddr_null)) {
/* If the receiver address is null, the strobe is sent to
prepare for an incoming broadcast packet. If this is the
case, we turn on the radio and wait for the incoming
broadcast packet. */
waiting_for_packet = 1;
on();
} else {
PRINTDEBUG("xmac: strobe not for us\n");
}
/* We are done processing the strobe and we therefore return
to the caller. */
return;
#if XMAC_CONF_ANNOUNCEMENTS
} else if(hdr->type == TYPE_ANNOUNCEMENT) {
packetbuf_hdrreduce(sizeof(struct xmac_hdr));
parse_announcements(packetbuf_addr(PACKETBUF_ADDR_SENDER));
#endif /* XMAC_CONF_ANNOUNCEMENTS */
} else if(hdr->type == TYPE_STROBE_ACK) {
PRINTDEBUG("xmac: stray strobe ack\n");
} else {
PRINTF("xmac: unknown type %u (%u/%u)\n", hdr->type,
packetbuf_datalen(), len);
}
} else {
PRINTF("xmac: failed to parse (%u)\n", packetbuf_totlen());
}
}
static long int
find_file (const char *s)
{
int level = 1;
long int idx = 0;
while (s[0] == '/')
{
if (s[1] == '\0')
{
s = ".";
break;
}
++s;
}
if (strcmp (s, ".") == 0)
return 0;
if (s[0] == '.' && s[1] == '/')
s += 2;
while (*s != '\0')
{
char *endp = strchrnul (s, '/');
PRINTF ("looking for %.*s, level %d\n", (int) (endp - s), s, level);
while (idx < nfiles && filesystem[idx].level >= level)
{
if (filesystem[idx].level == level
&& memcmp (s, filesystem[idx].name, endp - s) == 0
&& filesystem[idx].name[endp - s] == '\0')
break;
++idx;
}
if (idx == nfiles || filesystem[idx].level < level)
{
errno = ENOENT;
return -1;
}
if (*endp == '\0')
return idx + 1;
if (filesystem[idx].type != DT_DIR
&& (idx + 1 >= nfiles
|| filesystem[idx].level >= filesystem[idx + 1].level))
{
errno = ENOTDIR;
return -1;
}
++idx;
s = endp + 1;
++level;
}
errno = ENOENT;
return -1;
}
void process_keys(void)
{
#if CONFIG_NSK
char ip[50] = "";
char mask[50] = "";
/* netx_addr_t addr; */
ip4addr_t myip = 0;
#endif
acn_protect_t protect;
component_t *comp;
int cnt;
int x;
char cid_text[37];
#if CONFIG_SDT
cid_t cid;
cid_t dcid;
sdt_member_t *member;
#endif
bool WaitingForJoin = false;
bool WaitingForLeave = false;
int ch;
bool doexit = false;
/* wait for ip address (in host format)*/
#if CONFIG_NSK
while (!myip) {
myip = ntohl(netx_getmyip(NULL));
}
#endif
#if CONFIG_SDT
/* make a local component */
textToCid(cid_str1, cid);
textToCid(dcid_str1, dcid);
/* make our cid unique to us */
cid[15] = (uint8_t)(myip & 0xff);
/* create our local component */
local_component = sdt_add_component(cid, dcid, true, accBOTH, cbAPP);
/* fill in some required data */
if (local_component) {
/* local_component->callback = component_callback; */
strcpy(local_component->uacn, myuacn);
strcpy(local_component->fctn, myfctn);
}
#endif
/* main is debug thread */
while (!doexit) {
ch = _getch();
if (ch == EOF) {
break;
}
if (ch) {
if (WaitingForJoin || WaitingForLeave) {
if (ch < '1' || ch > '9') {
WaitingForJoin = false;
WaitingForLeave = false;
}
}
}
switch (ch) {
case 0:
/* do nothing */
break;
case 8: _putch(8); _putch(' '); _putch(8);
/* backspace */
break;
case 10: _putch(10);
break;
case 13: _putch(10);
/* lf */
break;
case 'j': case 'J':
PRINTF("%s","Enter component number to join: ");
WaitingForJoin = true;
break;
case 'l': case 'L':
PRINTF("%s","Enter component number to leave: ");
WaitingForLeave = true;
break;
#if CONFIG_SDT
case '1': case '2': case '3':
if (WaitingForJoin || WaitingForLeave) {
x = ch - '0';
protect = ACN_PORT_PROTECT();
comp = sdt_first_component();
cnt = 0;
while (comp) {
cnt++;
if (cnt == x) {
if (!comp->is_local) {
if (WaitingForJoin) {
PRINTF("Joining %d\n",cnt);
sdt_join(local_component, comp);
}
if (WaitingForLeave) {
PRINTF("Leaving %d\n",cnt);
sdt_leave(local_component, comp);
}
} else {
PRINTF("Nope, %d is local!\n", cnt);
}
}
comp = comp->next;
}
ACN_PORT_UNPROTECT(protect);
WaitingForJoin = false;
WaitingForLeave = false;
} else {
PRINTF("%s",".\n");
}
break;
#endif
#if CONFIG_SLP
case 'd': case 'D':
/* discover */
discover_acn(dcid_str1, discover_callback);
break;
#endif
#if CONFIG_NSK
case 'i': case 'I':
/* We copy to local as ntoa can not be reused... */
strcpy(ip, ntoa(netx_getmyip(0)));
strcpy(mask, ntoa(netx_getmyipmask(0)));
PRINTF("My IP: %s, mask %s\n", ip, mask);
break;
#endif
#if CONFIG_SDT
case 'c': case 'C':
protect = ACN_PORT_PROTECT();
comp = sdt_first_component();
cnt = 0;
while (comp) {
cnt++;
cidToText(comp->cid, cid_text);
member = NULL;
if (local_component->tx_channel) {
member = sdt_find_member_by_component(local_component->tx_channel, comp);
}
PRINTF("%d, %s %s\n", cnt, cid_text, comp->is_local?"(local)":(member?"(joined)":""));
comp = comp->next;
}
ACN_PORT_UNPROTECT(protect);
break;
#endif
#if CONFIG_SLP
case 'r': case 'R':
discover_register(local_component);
break;
case 'u':case 'U':
discover_deregister(local_component);
break;
#endif
#if CONFIG_SDT
case 's': case 'S':
slp_stats();
sdt_stats();
break;
#endif
case 3: case 'x': case 'X':
/* exit test app */
doexit = true;
break;
case 't': case 'T':
#if 0
{
rlp_txbuf_t *tx_buffer;
uint8_t *buf_start;
/* uint8_t *buffer; */
netx_INADDR(&addr) = DD2NIP(193,168,1,200);
netx_PORT(&addr) = htons(6000);
/* IP4_ADDR(&addr.sin_addr.S_un.S_addr, 192,168,1,200); */
/* Create packet buffer*/
tx_buffer = rlpm_new_txbuf(DEFAULT_MTU, local_component);
if (!tx_buffer) {
acnlog(LOG_ERR | LOG_SDT, "sdt_tx_join : failed to get new txbuf");
break;
}
buf_start = rlp_init_block(tx_buffer, NULL);
rlp_add_pdu(tx_buffer, buf_start, 49, NULL);
rlp_send_block(tx_buffer, local_component->tx_channel->sock, &addr);
rlpm_release_txbuf(tx_buffer);
}
break;
#endif
default:
if (ch >= ' ' && ch <= 126) {
_putch(ch);
}
}
}
#if CONFIG_SDT
if (local_component) {
sdt_del_component(local_component);
}
if (foreign_component) {
sdt_del_component(foreign_component);
}
#endif
PRINTF("%s","Shutting down...\n");
}
/*---------------------------------------------------------------------------*/
static void
sent_mesh(struct mesh_conn *mesh)
{
PRINTF("%d.%d: Sent mesh\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
}
void UserMain(void * pd) {
int x;
DWORD flag = 0;
int cnt;
InitializeStack();
GetDHCPAddressIfNecessary();
if (EthernetIP == 0) GetDHCPAddress();
OSChangePrio(MAIN_PRIO);
EnableAutoUpdate();
#ifdef _DEBUG
/* InitializeNetworkGDB_and_Wait(); */
InitializeNetworkGDB();
#endif
/* note, this may not work in all cases.
1) all systems might boot at the same time
2) when they get to this point, they may not have an ip yet
*/
/* init our acn stack */
acn_port_protect_startup();
#if CONFIG_NSK
srand(GetPreciseTime() + netx_getmyip(0));
netx_init();
netx_startup();
#endif
#if CONFIG_SLP
slp_init();
slp_open();
slp_active_discovery_start();
#endif
#if CONFIG_RLP
rlp_init();
#if CONFIG_SDT
sdt_init(); /* indirectly calls sdtm_init(), rlp_init(), rlpm_init() */
sdt_startup(true);
#endif
#if CONFIG_DMP
/* dmp_startup(); */
#endif
#endif /* RLP */
CreateTasks();
x = OSChangePrio( DEBUG_TERM_PRIORITY );
if (x) {
PRINTF("%s","OUCH\n");
}
PRINTF("%s","Hello ACN World\n");
ioctl( 0, IOCTL_CLR | IOCTL_RX_ECHO ); /* turn sdtin echo off */
process_keys();
/* shut things down - these require the threads to continue run... */
#if CONFIG_SDT
sdt_shutdown();
#endif
#if CONFIG_SLP
slp_close();
#endif
#if CONFIG_DMP
/* dmp_shutdown() */
#endif
/* shut down receive thread */
OSFlagClear(&recv_flag, 1);
PRINTF("%s","Waiting for task to recv to shut down..");
cnt = 0;
flag = 0;
while (!flag) {
cnt++;
if (cnt == 80) {
cnt = 0;
PRINTF("%s","\n");
}
PRINTF("%s",".");
flag = OSFlagState(&recv_flag);
}
/* shut down tick thread */
OSFlagClear(&tick_flag, 1);
PRINTF("%s","Waiting for task to tick to shut down..");
cnt = 0;
flag = 0;
while (!flag) {
cnt++;
if (cnt == 80) {
cnt = 0;
PRINTF("%s","\n");
}
PRINTF("%s",".");
flag = OSFlagState(&tick_flag);
}
#if CONFIG_NSK
netx_shutdown();
#endif
acn_port_protect_shutdown();
slp_stats();
sdt_stats();
PRINTF("%s","========================\n");
PRINTF("%s","\nDone....\n");
while (1) {
OSTimeDly(20);
}
}
/*---------------------------------------------------------------------------*/
static void
recv_mesh(struct mesh_conn *mesh, const rimeaddr_t *from, uint8_t hops)
{
struct rudolph1mh_conn *c = (struct rudolph1mh_conn *) ((char *) mesh
- offsetof(struct rudolph1mh_conn, mesh));
struct rudolph1mh_datapacket *p = packetbuf_dataptr();
PRINTF("%d.%d: Got mesh type %d from %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.type, from->u8[0], from->u8[1]);
if(!rimeaddr_cmp(&c->partner, from)){
if(!rimeaddr_cmp(&c->partner, &rimeaddr_null)){
rimeaddr_t lfrom;
PRINTF("%d.%d: Unexpected packet from %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
from->u8[0], from->u8[1]);
rimeaddr_copy(&lfrom, from);
send_busy(c, &lfrom);
return;
} else {
rimeaddr_copy(&c->partner, from);
}
}
if(p->h.type == TYPE_ACK){
if(p->h.s_id == c->s_id && p->h.chunk == c->highest_chunk){
ctimer_stop(&c->t);
rimeaddr_copy(&c->partner, &rimeaddr_null);
if(c->cb->read_done){
c->cb->read_done(c);
}
PRINTF("GOT ACK\n");
} else {
PRINTF("Unexpected ACK sid %i,%i C %i,%i\n", p->h.s_id, c->s_id, p->h.chunk, c->highest_chunk);
}
} else if(p->h.type == TYPE_NACK) {
c->nacks++;
PRINTF("%d.%d: Got NACK for %d:%d (%d:%d)\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.s_id, p->h.chunk,
c->s_id, c->chunk);
if(p->h.s_id == c->s_id) {
if(p->h.chunk < c->chunk) {
/* Format and send a repair packet */
PRINTF("%d.%d: sending repair for chunk %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk);
format_data(c, p->h.chunk);
mesh_send(&c->mesh, &c->partner);
}
}
else if(LT(p->h.s_id, c->s_id)) {
format_data(c, 0);
mesh_send(&c->mesh, &c->partner);
}
}
else if(p->h.type == TYPE_DATA ) {
/* This is a repair packet from someone else. */
PRINTF("%d.%d: got chunk %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk);
handle_data(c, p);
} else if(p->h.type == TYPE_FIN ) {
/* This is a repair packet from someone else. */
PRINTF("%d.%d: got last chunk %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
p->h.chunk);
if(!rimeaddr_cmp(&c->partner, &rimeaddr_null)){
handle_data(c, p);
}{
rimeaddr_copy(&c->partner, from);
}
send_ack(c);
rimeaddr_copy(&c->partner, &rimeaddr_null);
} else if(p->h.type == TYPE_BUSY){
PRINTF("%d.%d: %d.%d is busy\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
from->u8[0], from->u8[1]);
//Wait
}
}
void init() { PRINTF("Waiting 2 seconds");}
/*---------------------------------------------------------------------------*/
static void
node_packet_received(struct runicast_conn *c, const rimeaddr_t *from,
uint8_t seqno)
{
struct collect_conn *tc = (struct collect_conn *)
((char *)c - offsetof(struct collect_conn, runicast_conn));
int i;
/* To protect against forwarding duplicate packets, we keep a list
of recently forwarded packet seqnos. If the seqno of the current
packet exists in the list, we drop the packet. */
for(i = 0; i < NUM_RECENT_PACKETS; i++) {
if(recent_packets[i].seqno == packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID) &&
rimeaddr_cmp(&recent_packets[i].originator,
packetbuf_addr(PACKETBUF_ADDR_ESENDER))) {
PRINTF("%d.%d: dropping duplicate packet from %d.%d with seqno %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
recent_packets[i].originator.u8[0], recent_packets[i].originator.u8[1],
packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID));
/* Drop the packet. */
return;
}
}
recent_packets[recent_packet_ptr].seqno = packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID);
rimeaddr_copy(&recent_packets[recent_packet_ptr].originator,
packetbuf_addr(PACKETBUF_ADDR_ESENDER));
recent_packet_ptr = (recent_packet_ptr + 1) % NUM_RECENT_PACKETS;
if(tc->rtmetric == SINK) {
/* If we are the sink, we call the receive function. */
PRINTF("%d.%d: sink received packet from %d.%d via %d.%d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
packetbuf_addr(PACKETBUF_ADDR_ESENDER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_ESENDER)->u8[1],
from->u8[0], from->u8[1]);
if(tc->cb->recv != NULL) {
tc->cb->recv(packetbuf_addr(PACKETBUF_ADDR_ESENDER),
packetbuf_attr(PACKETBUF_ATTR_EPACKET_ID),
packetbuf_attr(PACKETBUF_ATTR_HOPS));
}
return;
} else if(packetbuf_attr(PACKETBUF_ATTR_TTL) > 1 &&
tc->rtmetric != RTMETRIC_MAX) {
/* If we are not the sink, we forward the packet to the best
neighbor. */
packetbuf_set_attr(PACKETBUF_ATTR_HOPS, packetbuf_attr(PACKETBUF_ATTR_HOPS) + 1);
packetbuf_set_attr(PACKETBUF_ATTR_TTL, packetbuf_attr(PACKETBUF_ATTR_TTL) - 1);
PRINTF("%d.%d: packet received from %d.%d via %d.%d, forwarding %d\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1],
packetbuf_addr(PACKETBUF_ADDR_ESENDER)->u8[0],
packetbuf_addr(PACKETBUF_ADDR_ESENDER)->u8[1],
from->u8[0], from->u8[1], tc->forwarding);
if(packetqueue_enqueue_packetbuf(&forwarding_queue, FORWARD_PACKET_LIFETIME,
tc)) {
send_queued_packet();
} else {
PRINTF("%d.%d: packet dropped: no queue buffer available\n",
rimeaddr_node_addr.u8[0], rimeaddr_node_addr.u8[1]);
}
}
return;
}
GLOBAL Int UMF_report_vector
(
Int n,
const double Xx [ ],
const double Xz [ ],
Int prl,
Int user,
Int scalar
)
{
Int n2, i ;
if (user || prl >= 4)
{
PRINTF (("dense vector, n = "ID". ", n)) ;
}
if (user)
{
if (!Xx)
{
PRINTF (("ERROR: vector not present\n\n")) ;
return (UMFPACK_ERROR_argument_missing) ;
}
if (n < 0)
{
PRINTF (("ERROR: length of vector is < 0\n\n")) ;
return (UMFPACK_ERROR_n_nonpositive) ;
}
}
if (user || prl >= 4)
{
PRINTF4 (("\n")) ;
}
if (prl == 4)
{
/* print level of 4 */
n2 = MIN (10, n) ;
for (i = 0 ; i < n2 ; i++)
{
print_value (i, Xx, Xz, scalar) ;
}
if (n2 < n)
{
PRINTF ((" ...\n")) ;
print_value (n-1, Xx, Xz, scalar) ;
}
}
else if (prl > 4)
{
/* print level 4 or more */
for (i = 0 ; i < n ; i++)
{
print_value (i, Xx, Xz, scalar) ;
}
}
PRINTF4 ((" dense vector ")) ;
if (user || prl >= 4)
{
PRINTF (("OK\n\n")) ;
}
return (UMFPACK_OK) ;
}
PROCESS_THREAD(datetime_service_process, ev, data) {
static struct etimer update_timer;
static int valid_counter;
PROCESS_BEGIN();
timestamp = 0;
time_valid = false;
valid_counter = VALID_TIME;
etimer_set(&update_timer, CLOCK_SECOND * UPDATE_INTERVALL);
while(1) {
PROCESS_WAIT_EVENT();
if(ev == PROCESS_EVENT_TIMER) {
PRINTF("Time: %d:%d:%d\t%d.%d.%d Day: %d Valid: %d\n", current_dt.hour, current_dt.minute, current_dt.second, current_dt.day, current_dt.month, current_dt.year, current_dt.weekday, time_valid);
if(etimer_expired(&update_timer)){
etimer_reset(&update_timer);
}
timestamp++; // update timestamp
if(valid_counter < VALID_TIME) {
valid_counter+=1;
} else {
time_valid = false;
}
current_dt.second+=1;
if(current_dt.second > 59) {
current_dt.second = 0;
current_dt.minute+=1;
if(current_dt.minute > 59) {
current_dt.minute = 0;
current_dt.hour+=1;
if(current_dt.hour > 23) {
current_dt.hour = 0;
current_dt.day+=1;
current_dt.weekday+=1;
if(current_dt.weekday>6) {
current_dt.weekday=0;
}
if( ((current_dt.month==1||current_dt.month==3||current_dt.month==5||current_dt.month==7||current_dt.month==8||current_dt.month==10||current_dt.month==12)&¤t_dt.day>31) || ((current_dt.month==4||current_dt.month==6||current_dt.month==9||current_dt.month==11)&¤t_dt.day>30) || (current_dt.month==2 && current_dt.day>28)) { //TODO Schaltjahre >.<
current_dt.day=0;
current_dt.month+=1;
if(current_dt.month>12) {
current_dt.month=0;
current_dt.year+=1;
}
}
}
}
}
} else if(ev == dt_update_event) {
PRINTF("Time: Got update.\n");
current_dt = *(struct datetime*)&(((struct hxb_envelope*)data)->value.data);
time_valid = true;
valid_counter = 0;
etimer_restart(&update_timer);
free(data);
}
}
PROCESS_END();
}
Int KLU_sort
(
KLU_symbolic *Symbolic,
KLU_numeric *Numeric,
KLU_common *Common
)
{
Int *R, *W, *Tp, *Ti, *Lip, *Uip, *Llen, *Ulen ;
Entry *Tx ;
Unit **LUbx ;
Int n, nk, nz, block, nblocks, maxblock, k1 ;
size_t m1 ;
if (Common == NULL)
{
return (FALSE) ;
}
Common->status = KLU_OK ;
n = Symbolic->n ;
R = Symbolic->R ;
nblocks = Symbolic->nblocks ;
maxblock = Symbolic->maxblock ;
Lip = Numeric->Lip ;
Llen = Numeric->Llen ;
Uip = Numeric->Uip ;
Ulen = Numeric->Ulen ;
LUbx = (Unit **) Numeric->LUbx ;
m1 = ((size_t) maxblock) + 1 ;
/* allocate workspace */
nz = MAX (Numeric->max_lnz_block, Numeric->max_unz_block) ;
W = KLU_malloc (maxblock, sizeof (Int), Common) ;
Tp = KLU_malloc (m1, sizeof (Int), Common) ;
Ti = KLU_malloc (nz, sizeof (Int), Common) ;
Tx = KLU_malloc (nz, sizeof (Entry), Common) ;
PRINTF (("\n======================= Start sort:\n")) ;
if (Common->status == KLU_OK)
{
/* sort each block of L and U */
for (block = 0 ; block < nblocks ; block++)
{
k1 = R [block] ;
nk = R [block+1] - k1 ;
if (nk > 1)
{
PRINTF (("\n-------------------block: %d nk %d\n", block, nk)) ;
sort (nk, Lip + k1, Llen + k1, LUbx [block], Tp, Ti, Tx, W) ;
sort (nk, Uip + k1, Ulen + k1, LUbx [block], Tp, Ti, Tx, W) ;
}
}
}
PRINTF (("\n======================= sort done.\n")) ;
/* free workspace */
KLU_free (W, maxblock, sizeof (Int), Common) ;
KLU_free (Tp, m1, sizeof (Int), Common) ;
KLU_free (Ti, nz, sizeof (Int), Common) ;
KLU_free (Tx, nz, sizeof (Entry), Common) ;
return (Common->status == KLU_OK) ;
}
error_t
parse_message(coap_packet_t* packet, u8_t* buf, u16_t size)
{
u16_t processed = 0;
u16_t i = 0;
PRINTF("parse_message size %d-->\n",size);
init_packet(packet);
packet->ver = (buf[0] & COAP_HEADER_VERSION_MASK) >> COAP_HEADER_VERSION_POSITION;
packet->type = (buf[0] & COAP_HEADER_TYPE_MASK) >> COAP_HEADER_TYPE_POSITION;
packet->option_count = buf[0] & COAP_HEADER_OPTION_COUNT_MASK;
packet->code = buf[1];
packet->tid = (buf[2] << 8) + buf[3];
processed += 4;
if (packet->option_count) {
u8_t option_index = 0;
u8_t option_delta;
u16_t option_len;
u8_t* option_buf = buf + processed;
packet->options = (header_option_t*)allocate_buffer(sizeof(header_option_t) * packet->option_count);
if (!packet->options) {
return MEMORY_ALLOC_ERR;
}
header_option_t* current_option = packet->options;
header_option_t* prev_option = NULL;
while ((option_index < packet->option_count) && (i <= (size - processed))) {
option_delta = (option_buf[i] & COAP_HEADER_OPTION_DELTA_MASK)
>> COAP_HEADER_OPTION_DELTA_POSITION;
option_len = (option_buf[i] & COAP_HEADER_OPTION_SHORT_LENGTH_MASK);
i++;
if (option_len == 0xf) {
option_len += option_buf[i];
i++;
}
current_option->option = option_delta;
current_option->len = option_len;
current_option->value = option_buf + i;
if (option_index) {
prev_option->next = current_option;
/*This field defines the difference between the option Type of
* this option and the previous option (or zero for the first option)*/
current_option->option += prev_option->option;
}
if (current_option->option == Option_Type_Uri_Path) {
if (!packet->url) {
/* Allocate space for url */
packet->url = allocate_buffer(MAX_URI_PATH_LENGTH);
if (!packet->url){
return MEMORY_ALLOC_ERR;
}
} else {
if (packet->url_len + 1 <= MAX_URI_PATH_LENGTH) {
packet->url[packet->url_len++] = '/';
} else {
return MEMORY_ALLOC_ERR;
}
}
if (packet->url_len + current_option->len <= MAX_URI_PATH_LENGTH) {
strncpy(&packet->url[packet->url_len], (char*) current_option->value,
current_option->len);
packet->url_len += current_option->len;
} else {
return MEMORY_ALLOC_ERR;
}
} else if (current_option->option == Option_Type_Uri_Query) {
packet->query = (char*) current_option->value;
packet->query_len = current_option->len;
}
i += option_len;
option_index++;
prev_option = current_option;
if (option_index < packet->option_count) {
/* There are still options to parse */
current_option++;
}
}
if (i > (size - processed)) {
/* Out of bounds. Bad request? */
return BAD_REQUEST_ERR;
}
current_option->next = NULL;
}
void mid_task_init(void)
{
PRINTF("mid_task_init \n");
return ;
}
void printInt32(char* ptr) {
PRINTF("%d", *((uint32_t*)ptr));
}
static void rtsp_ginfo_print(rtsp_server_config *config)
{
PRINTF("rtsp_ginfo_print: config= %p\n", config);
PRINTF("s_port=%d,active=%d,s_mtu=%d,mult_flag=%d,ip=%s:%d\n", config->s_port, config->active, config->s_mtu, config->mult_flag, config->mult_ip, config->mult_port);
}