syn2cat
/
syndilights
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
syndilights/open-lighting-architecture/libartnet-1.1.0/artnet/receive.c

913 lines
27 KiB
C
Raw Blame History

/*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* receive.c
* Handles the receiving of datagrams
* Copyright (C) 2004-2007 Simon Newton
*/
#include "private.h"
uint8_t _make_addr(uint8_t subnet, uint8_t addr);
void check_merge_timeouts(node n, int port);
void merge(node n, int port, int length, uint8_t *latest);
/*
* Checks if the callback is defined, if so call it passing the packet and
* the user supplied data.
* If the callbacks return a non-zero result, further processing is canceled.
*/
int check_callback(node n, artnet_packet p, callback_t callback) {
if (callback.fh != NULL)
return callback.fh(n, p, callback.data);
return 0;
}
/*
* Handle an artpoll packet
*/
int handle_poll(node n, artnet_packet p) {
// run callback if defined
if (check_callback(n, p, n->callbacks.poll))
return ARTNET_EOK;
if (n->state.node_type != ARTNET_RAW) {
//if we're told to unicast further replies
if (p->data.ap.ttm & TTM_REPLY_MASK) {
n->state.reply_addr = p->from;
} else {
n->state.reply_addr.s_addr = n->state.bcast_addr.s_addr;
}
// if we are told to send updates when node conditions change
if (p->data.ap.ttm & TTM_BEHAVIOUR_MASK) {
n->state.send_apr_on_change = TRUE;
} else {
n->state.send_apr_on_change = FALSE;
}
return artnet_tx_poll_reply(n, TRUE);
}
return ARTNET_EOK;
}
/*
* handle an art poll reply
*/
void handle_reply(node n, artnet_packet p) {
// update the node list
artnet_nl_update(&n->node_list, p);
// run callback if defined
if (check_callback(n, p, n->callbacks.reply))
return;
}
/*
* handle a art dmx packet
*/
void handle_dmx(node n, artnet_packet p) {
int i, data_length;
output_port_t *port;
in_addr_t ipA, ipB;
// run callback if defined
if (check_callback(n, p, n->callbacks.dmx))
return;
data_length = (int) bytes_to_short(p->data.admx.lengthHi,
p->data.admx.length);
data_length = min(data_length, ARTNET_DMX_LENGTH);
// find matching output ports
for (i = 0; i < ARTNET_MAX_PORTS; i++) {
// if the addr matches and this port is enabled
if (p->data.admx.universe == n->ports.out[i].port_addr &&
n->ports.out[i].port_enabled) {
port = &n->ports.out[i];
ipA = port->ipA.s_addr;
ipB = port->ipB.s_addr;
// ok packet matches this port
n->ports.out[i].port_status = n->ports.out[i].port_status | PORT_STATUS_ACT_MASK;
/**
* 9 cases for merging depending on what the stored ips are.
* here's the truth table
*
*
* \ ipA # # # #
* ------ # empty # # #
* ipB \ # ( 0 ) # p.from # ! p.from #
* ##################################################
* # new node # continued # start #
* empty # first # trans- # merge #
* (0) # packet # mission # #
* ##################################################
* #continued # # cont #
* p.from # trans- # invalid! # merge #
* # mission # # #
* ##################################################
* # start # cont # #
* ! p.from # merge # merge # discard #
* # # # #
* ##################################################
*
* The merge exits when:
* o ACCancel command is received in an ArtAddress packet
* (this is done in handle_address )
* o no data is recv'ed from one source in 10 seconds
*
*/
check_merge_timeouts(n,i);
if (ipA == 0 && ipB == 0) {
// first packet recv on this port
port->ipA.s_addr = p->from.s_addr;
port->timeA = time(NULL);
memcpy(&port->dataA, &p->data.admx.data, data_length);
port->length = data_length;
memcpy(&port->data, &p->data.admx.data, data_length);
}
else if (ipA == p->from.s_addr && ipB == 0) {
//continued transmission from the same ip (source A)
port->timeA = time(NULL);
memcpy(&port->dataA, &p->data.admx.data, data_length);
port->length = data_length;
memcpy(&port->data, &p->data.admx.data, data_length);
}
else if (ipA == 0 && ipB == p->from.s_addr) {
//continued transmission from the same ip (source B)
port->timeB = time(NULL);
memcpy(&port->dataB, &p->data.admx.data, data_length);
port->length = data_length;
memcpy(&port->data, &p->data.admx.data, data_length);
}
else if (ipA != p->from.s_addr && ipB == 0) {
// new source, start the merge
port->ipB.s_addr = p->from.s_addr;
port->timeB = time(NULL);
memcpy(&port->dataB, &p->data.admx.data,data_length);
port->length = data_length;
// merge, newest data is port B
merge(n,i,data_length, port->dataB);
// send reply if needed
}
else if (ipA == 0 && ipB == p->from.s_addr) {
// new source, start the merge
port->ipA.s_addr = p->from.s_addr;
port->timeB = time(NULL);
memcpy(&port->dataB, &p->data.admx.data,data_length);
port->length = data_length;
// merge, newest data is portA
merge(n,i,data_length, port->dataA);
// send reply if needed
}
else if (ipA == p->from.s_addr && ipB != p->from.s_addr) {
// continue merge
port->timeA = time(NULL);
memcpy(&port->dataA, &p->data.admx.data,data_length);
port->length = data_length;
// merge, newest data is portA
merge(n,i,data_length, port->dataA);
}
else if (ipA != p->from.s_addr && ipB == p->from.s_addr) {
// continue merge
port->timeB = time(NULL);
memcpy(&port->dataB, &p->data.admx.data,data_length);
port->length = data_length;
// merge newest data is portB
merge(n,i,data_length, port->dataB);
}
else if (ipA == p->from.s_addr && ipB == p->from.s_addr) {
// err_warn("In handle_dmx, source matches both buffers, this shouldn't be happening!\n");
}
else if (ipA != p->from.s_addr && ipB != p->from.s_addr) {
// err_warn("In handle_dmx, more than two sources, discarding data\n");
}
else {
// err_warn("In handle_dmx, no cases matched, this shouldn't happen!\n");
}
// do the dmx callback here
if (n->callbacks.dmx_c.fh != NULL)
n->callbacks.dmx_c.fh(n,i, n->callbacks.dmx_c.data);
}
}
return;
}
/**
* handle art address packet.
* This can reprogram certain nodes settings such as short/long name, port
* addresses, subnet address etc.
*
*/
int handle_address(node n, artnet_packet p) {
int i, old_subnet;
int addr[ARTNET_MAX_PORTS];
int ret;
if (check_callback(n, p, n->callbacks.address))
return ARTNET_EOK;
// servers (and raw nodes) don't respond to address packets
if (n->state.node_type == ARTNET_SRV || n->state.node_type == ARTNET_RAW)
return ARTNET_EOK;
// reprogram shortname if required
if (p->data.addr.shortname[0] != PROGRAM_DEFAULTS &&
p->data.addr.shortname[0] != PROGRAM_NO_CHANGE) {
memcpy(&n->state.short_name, &p->data.addr.shortname, ARTNET_SHORT_NAME_LENGTH);
n->state.report_code = ARTNET_RCSHNAMEOK;
}
// reprogram long name if required
if (p->data.addr.longname[0] != PROGRAM_DEFAULTS &&
p->data.addr.longname[0] != PROGRAM_NO_CHANGE) {
memcpy(&n->state.long_name, &p->data.addr.longname, ARTNET_LONG_NAME_LENGTH);
n->state.report_code = ARTNET_RCLONAMEOK;
}
// first of all store existing port addresses
// then we can work out if they change
for (i=0; i< ARTNET_MAX_PORTS; i++) {
addr[i] = n->ports.in[i].port_addr;
}
// program subnet
old_subnet = p->data.addr.subnet;
if (p->data.addr.subnet == PROGRAM_DEFAULTS) {
// reset to defaults
n->state.subnet = n->state.default_subnet;
n->state.subnet_net_ctl = FALSE;
} else if (p->data.addr.subnet & PROGRAM_CHANGE_MASK) {
n->state.subnet = p->data.addr.subnet & ~PROGRAM_CHANGE_MASK;
n->state.subnet_net_ctl = TRUE;
}
// check if subnet has actually changed
if (old_subnet != n->state.subnet) {
// if it does we need to change all port addresses
for(i=0; i< ARTNET_MAX_PORTS; i++) {
n->ports.in[i].port_addr = _make_addr(n->state.subnet, n->ports.in[i].port_addr);
n->ports.out[i].port_addr = _make_addr(n->state.subnet, n->ports.out[i].port_addr);
}
}
// program swins
for (i =0; i < ARTNET_MAX_PORTS; i++) {
if (p->data.addr.swin[i] == PROGRAM_NO_CHANGE) {
continue;
} else if (p->data.addr.swin[i] == PROGRAM_DEFAULTS) {
// reset to defaults
n->ports.in[i].port_addr = _make_addr(n->state.subnet, n->ports.in[i].port_default_addr);
n->ports.in[i].port_net_ctl = FALSE;
} else if ( p->data.addr.swin[i] & PROGRAM_CHANGE_MASK) {
n->ports.in[i].port_addr = _make_addr(n->state.subnet, p->data.addr.swin[i]);
n->ports.in[i].port_net_ctl = TRUE;
}
}
// program swouts
for (i =0; i < ARTNET_MAX_PORTS; i++) {
if (p->data.addr.swout[i] == PROGRAM_NO_CHANGE) {
continue;
} else if (p->data.addr.swout[i] == PROGRAM_DEFAULTS) {
// reset to defaults
n->ports.out[i].port_addr = _make_addr(n->state.subnet, n->ports.out[i].port_default_addr);
n->ports.out[i].port_net_ctl = FALSE;
n->ports.out[i].port_enabled = TRUE;
} else if ( p->data.addr.swout[i] & PROGRAM_CHANGE_MASK) {
n->ports.out[i].port_addr = _make_addr(n->state.subnet, p->data.addr.swout[i]);
n->ports.in[i].port_net_ctl = TRUE;
n->ports.out[i].port_enabled = TRUE;
}
}
// reset sequence numbers if the addresses change
for (i=0; i< ARTNET_MAX_PORTS; i++) {
if (addr[i] != n->ports.in[i].port_addr)
n->ports.in[i].seq = 0;
}
// check command
switch (p->data.addr.command) {
case ARTNET_PC_CANCEL:
// fix me
break;
case ARTNET_PC_RESET:
n->ports.out[0].port_status = n->ports.out[0].port_status & ~PORT_STATUS_DMX_SIP & ~PORT_STATUS_DMX_TEST & ~PORT_STATUS_DMX_TEXT;
// need to force a rerun of short tests here
break;
case ARTNET_PC_MERGE_LTP_O:
n->ports.out[0].merge_mode = ARTNET_MERGE_LTP;
n->ports.out[0].port_status = n->ports.out[0].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_LTP_1:
n->ports.out[1].merge_mode = ARTNET_MERGE_LTP;
n->ports.out[1].port_status = n->ports.out[1].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_LTP_2:
n->ports.out[2].merge_mode = ARTNET_MERGE_LTP;
n->ports.out[2].port_status = n->ports.out[2].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_LTP_3:
n->ports.out[3].merge_mode = ARTNET_MERGE_LTP;
n->ports.out[3].port_status = n->ports.out[3].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_HTP_0:
n->ports.out[0].merge_mode = ARTNET_MERGE_HTP;
n->ports.out[0].port_status = n->ports.out[0].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_HTP_1:
n->ports.out[1].merge_mode = ARTNET_MERGE_HTP;
n->ports.out[1].port_status = n->ports.out[1].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_HTP_2:
n->ports.out[2].merge_mode = ARTNET_MERGE_HTP;
n->ports.out[2].port_status = n->ports.out[2].port_status | PORT_STATUS_LPT_MODE;
break;
case ARTNET_PC_MERGE_HTP_3:
n->ports.out[3].merge_mode = ARTNET_MERGE_HTP;
n->ports.out[3].port_status = n->ports.out[3].port_status | PORT_STATUS_LPT_MODE;
break;
}
if (n->callbacks.program_c.fh != NULL)
n->callbacks.program_c.fh(n , n->callbacks.program_c.data);
if ((ret = artnet_tx_build_art_poll_reply(n)))
return ret;
return artnet_tx_poll_reply(n, TRUE);
}
/*
* handle art input.
* ArtInput packets can disable input ports.
*/
int _artnet_handle_input(node n, artnet_packet p) {
int i, ports, ret;
if (check_callback(n, p, n->callbacks.input))
return ARTNET_EOK;
// servers (and raw nodes) don't respond to input packets
if (n->state.node_type != ARTNET_NODE && n->state.node_type != ARTNET_MSRV)
return ARTNET_EOK;
ports = min( p->data.ainput.numbports, ARTNET_MAX_PORTS);
for (i =0; i < ports; i++) {
if (p->data.ainput.input[i] & PORT_DISABLE_MASK) {
// disable
n->ports.in[i].port_status = n->ports.in[i].port_status | PORT_STATUS_DISABLED_MASK;
} else {
// enable
n->ports.in[i].port_status = n->ports.in[i].port_status & ~PORT_STATUS_DISABLED_MASK;
}
}
if ((ret = artnet_tx_build_art_poll_reply(n)))
return ret;
return artnet_tx_poll_reply(n, TRUE);
}
/***
* handle tod request packet
*/
int handle_tod_request(node n, artnet_packet p) {
int i, j, limit;
int ret = ARTNET_EOK;
if (check_callback(n, p, n->callbacks.todrequest))
return ARTNET_EOK;
if (n->state.node_type != ARTNET_NODE)
return ARTNET_EOK;
// limit to 32
limit = min(ARTNET_MAX_RDM_ADCOUNT, p->data.todreq.adCount);
// this should always be true
if (p->data.todreq.command == 0x00) {
for (i=0; i < limit; i++) {
for (j=0; j < ARTNET_MAX_PORTS; j++) {
if (n->ports.out[j].port_addr == p->data.todreq.address[i] &&
n->ports.out[j].port_enabled) {
// reply with tod
ret = ret || artnet_tx_tod_data(n, j);
}
}
}
}
// err_warn("tod request received but command is 0x%02hhx rather than 0x00\n", p->data.todreq.command);
return ret;
}
/**
* handle tod data packet
*
* we don't maintain a tod of whats out on the network,
* the calling app can deal with this.
*/
void handle_tod_data(node n, artnet_packet p) {
if (check_callback(n, p, n->callbacks.toddata))
return;
// pass data to app
// if (n->callbacks.rdm_tod_c.fh != NULL)
// n->callbacks.rdm_tod_c.fh(n, i, n->callbacks.rdm_tod_c.data);
return;
}
int handle_tod_control(node n, artnet_packet p) {
int i;
int ret = ARTNET_EOK;
if (check_callback(n, p, n->callbacks.todcontrol))
return ARTNET_EOK;
for (i=0; i < ARTNET_MAX_PORTS; i++) {
if (n->ports.out[i].port_addr == p->data.todcontrol.address &&
n->ports.out[i].port_enabled) {
if (p->data.todcontrol.cmd == ARTNET_TOD_FLUSH) {
// flush tod for this port
flush_tod(&n->ports.out[i].port_tod);
//initiate full rdm discovery
// do callback here
if (n->callbacks.rdm_init_c.fh != NULL)
n->callbacks.rdm_init_c.fh(n, i, n->callbacks.rdm_init_c.data);
// not really sure what to do here, the calling app should do a rdm
// init and call artnet_add_rdm_devices() which will send a tod data
// but do we really trust the caller ?
// Instead we'll send an empty tod data and then another one a bit later
// when our tod is populated
}
// reply with tod
ret = ret || artnet_tx_tod_data(n, i);
}
}
return ret;
}
/**
* handle rdm packet
*
*/
void handle_rdm(node n, artnet_packet p) {
if (check_callback(n, p, n->callbacks.rdm))
return;
printf("rdm data\n");
// hell dodgy
if (n->callbacks.rdm_c.fh != NULL)
n->callbacks.rdm_c.fh(n, p->data.rdm.address, p->data.rdm.data, ARTNET_MAX_RDM_DATA, n->callbacks.rdm_c.data);
return;
}
/**
* handle a firmware master
*/
// THIS NEEDS TO BE CHECKED FOR BUFFER OVERFLOWS
// IMPORTANT!!!!
int handle_firmware(node n, artnet_packet p) {
int length, offset, block_length, total_blocks, block_id;
artnet_firmware_status_code response_code = ARTNET_FIRMWARE_FAIL;
// run callback if defined
if (check_callback(n, p, n->callbacks.firmware))
return ARTNET_EOK;
/*
* What happens if an upload is less than 512 bytes ?????
*/
if ( p->data.firmware.type == ARTNET_FIRMWARE_FIRMFIRST ||
p->data.firmware.type == ARTNET_FIRMWARE_UBEAFIRST) {
// a new transfer is initiated
if (n->firmware.peer.s_addr == 0) {
//new transfer
// these are 2 byte words, so we get a total of 1k of data per packet
length = artnet_misc_nbytes_to_32( p->data.firmware.length ) *
sizeof(p->data.firmware.data[0]);
// set parameters
n->firmware.peer.s_addr = p->from.s_addr;
n->firmware.data = malloc(length);
if (n->firmware.data == NULL) {
artnet_error_malloc();
return ARTNET_EMEM;
}
n->firmware.bytes_total = length;
n->firmware.last_time = time(NULL);
n->firmware.expected_block = 1;
// check if this is a ubea upload or not
if (p->data.firmware.type == ARTNET_FIRMWARE_FIRMFIRST)
n->firmware.ubea = 0;
else
n->firmware.ubea = 1;
// take the minimum of the total length and the max packet size
block_length = min((unsigned int) length, ARTNET_FIRMWARE_SIZE *
sizeof(p->data.firmware.data[0]));
memcpy(n->firmware.data, p->data.firmware.data, block_length);
n->firmware.bytes_current = block_length;
if (block_length == length) {
// this is the first and last packet
// upload was less than 1k bytes
// this behaviour isn't in the spec, presumably no firmware will be less that 1k
response_code = ARTNET_FIRMWARE_ALLGOOD;
// do the callback here
if (n->callbacks.firmware_c.fh != NULL)
n->callbacks.firmware_c.fh(n,
n->firmware.ubea,
n->firmware.data,
n->firmware.bytes_total,
n->callbacks.firmware_c.data);
} else {
response_code = ARTNET_FIRMWARE_BLOCKGOOD;
}
} else {
// already in a transfer
printf("First, but already for a packet\n");
// send a failure
response_code = ARTNET_FIRMWARE_FAIL;
}
} else if (p->data.firmware.type == ARTNET_FIRMWARE_FIRMCONT ||
p->data.firmware.type == ARTNET_FIRMWARE_UBEACONT) {
// continued transfer
length = artnet_misc_nbytes_to_32(p->data.firmware.length) *
sizeof(p->data.firmware.data[0]);
total_blocks = length / ARTNET_FIRMWARE_SIZE / 2 + 1;
block_length = ARTNET_FIRMWARE_SIZE * sizeof(uint16_t);
block_id = p->data.firmware.blockId;
// ok the blockid field is only 1 byte, so it wraps back to 0x00 we
// need to watch for this
if (n->firmware.expected_block > UINT8_MAX &&
(n->firmware.expected_block % (UINT8_MAX+1)) == p->data.firmware.blockId) {
block_id = n->firmware.expected_block;
}
offset = block_id * ARTNET_FIRMWARE_SIZE;
if (n->firmware.peer.s_addr == p->from.s_addr &&
length == n->firmware.bytes_total &&
block_id < total_blocks-1) {
memcpy(n->firmware.data + offset, p->data.firmware.data, block_length);
n->firmware.bytes_current += block_length;
n->firmware.expected_block++;
response_code = ARTNET_FIRMWARE_BLOCKGOOD;
} else {
printf("cont, ips don't match or length has changed or out of range block num\n" );
// in a transfer not from this ip
response_code = ARTNET_FIRMWARE_FAIL;
}
} else if (p->data.firmware.type == ARTNET_FIRMWARE_FIRMLAST ||
p->data.firmware.type == ARTNET_FIRMWARE_UBEALAST) {
length = artnet_misc_nbytes_to_32( p->data.firmware.length) *
sizeof(p->data.firmware.data[0]);
total_blocks = length / ARTNET_FIRMWARE_SIZE / 2 + 1;
// length should be the remaining data
block_length = n->firmware.bytes_total % (ARTNET_FIRMWARE_SIZE * sizeof(uint16_t));
block_id = p->data.firmware.blockId;
// ok the blockid field is only 1 byte, so it wraps back to 0x00 we
// need to watch for this
if (n->firmware.expected_block > UINT8_MAX &&
(n->firmware.expected_block % (UINT8_MAX+1)) == p->data.firmware.blockId) {
block_id = n->firmware.expected_block;
}
offset = block_id * ARTNET_FIRMWARE_SIZE;
if (n->firmware.peer.s_addr == p->from.s_addr &&
length == n->firmware.bytes_total &&
block_id == total_blocks-1) {
// all the checks work out
memcpy(n->firmware.data + offset, p->data.firmware.data, block_length);
n->firmware.bytes_current += block_length;
// do the callback here
if (n->callbacks.firmware_c.fh != NULL)
n->callbacks.firmware_c.fh(n, n->firmware.ubea,
n->firmware.data,
n->firmware.bytes_total / sizeof(p->data.firmware.data[0]),
n->callbacks.firmware_c.data);
// reset values and free
reset_firmware_upload(n);
response_code = ARTNET_FIRMWARE_ALLGOOD;
printf("Firmware upload complete\n");
} else if (n->firmware.peer.s_addr != p->from.s_addr) {
// in a transfer not from this ip
printf("last, ips don't match\n" );
response_code = ARTNET_FIRMWARE_FAIL;
} else if (length != n->firmware.bytes_total) {
// they changed the length mid way thru a transfer
printf("last, lengths have changed %d %d\n", length, n->firmware.bytes_total);
response_code = ARTNET_FIRMWARE_FAIL;
} else if (block_id != total_blocks -1) {
// the blocks don't match up
printf("This is the last block, but not according to the lengths %d %d\n", block_id, total_blocks -1);
response_code = ARTNET_FIRMWARE_FAIL;
}
}
return artnet_tx_firmware_reply(n, p->from.s_addr, response_code);
}
/**
* handle an firmware reply
*/
int handle_firmware_reply(node n, artnet_packet p) {
node_entry_private_t *ent;
// run callback if defined
if (check_callback(n, p, n->callbacks.firmware_reply))
return ARTNET_EOK;
ent = find_entry_from_ip(&n->node_list, p->from);
// node doesn't exist in our list, or we're not doing a transfer to this node
if (ent== NULL || ent->firmware.bytes_total == 0)
return ARTNET_EOK;
// three types of response, ALLGOOD, BLOCKGOOD and FIRMFAIL
if (p->data.firmwarer.type == ARTNET_FIRMWARE_ALLGOOD) {
if (ent->firmware.bytes_total == ent->firmware.bytes_current) {
// transfer complete
// do the callback
if (ent->firmware.callback != NULL)
ent->firmware.callback(n, ARTNET_FIRMWARE_ALLGOOD, ent->firmware.user_data);
memset(&ent->firmware, 0x0, sizeof(firmware_transfer_t));
} else {
// random ALLGOOD received, don't let this abort the transfer
printf("FIRMWARE_ALLGOOD received before transfer completed\n");
}
} else if (p->data.firmwarer.type == ARTNET_FIRMWARE_FAIL) {
// do the callback
if (ent->firmware.callback != NULL)
ent->firmware.callback(n, ARTNET_FIRMWARE_FAIL, ent->firmware.user_data);
// cancel transfer
memset(&ent->firmware, 0x0, sizeof(firmware_transfer_t));
} else if (p->data.firmwarer.type == ARTNET_FIRMWARE_BLOCKGOOD) {
// send the next block (only if we're not done yet)
if (ent->firmware.bytes_total != ent->firmware.bytes_current) {
return artnet_tx_firmware_packet(n, &ent->firmware);
}
}
return ARTNET_EOK;
}
/*
* have to sort this one out.
*/
void handle_ipprog(node n, artnet_packet p) {
if (check_callback(n, p, n->callbacks.ipprog))
return;
printf("in ipprog\n");
}
/*
* The main handler for an artnet packet. calls
* the appropriate handler function
*/
int handle(node n, artnet_packet p) {
if (check_callback(n, p, n->callbacks.recv))
return 0;
switch (p->type) {
case ARTNET_POLL:
handle_poll(n, p);
break;
case ARTNET_REPLY:
handle_reply(n,p);
break;
case ARTNET_DMX:
handle_dmx(n, p);
break;
case ARTNET_ADDRESS:
handle_address(n, p);
break;
case ARTNET_INPUT:
_artnet_handle_input(n, p);
break;
case ARTNET_TODREQUEST:
handle_tod_request(n, p);
break;
case ARTNET_TODDATA:
handle_tod_data(n, p);
break;
case ARTNET_TODCONTROL:
handle_tod_control(n, p);
break;
case ARTNET_RDM:
handle_rdm(n, p);
break;
case ARTNET_VIDEOSTEUP:
printf("vid setup\n");
break;
case ARTNET_VIDEOPALETTE:
printf("video palette\n");
break;
case ARTNET_VIDEODATA:
printf("video data\n");
break;
case ARTNET_MACMASTER:
printf("mac master\n");
break;
case ARTNET_MACSLAVE:
printf("mac slave\n");
break;
case ARTNET_FIRMWAREMASTER:
handle_firmware(n, p);
break;
case ARTNET_FIRMWAREREPLY:
handle_firmware_reply(n, p);
break;
case ARTNET_IPPROG :
handle_ipprog(n, p);
break;
case ARTNET_IPREPLY:
printf("ip reply\n");
break;
case ARTNET_MEDIA:
printf("media \n");
break;
case ARTNET_MEDIAPATCH:
printf("media patch\n");
break;
case ARTNET_MEDIACONTROLREPLY:
printf("media control reply\n");
break;
default:
n->state.report_code = ARTNET_RCPARSEFAIL;
printf("artnet but not yet implemented!, op was %hx\n", p->type);
}
return 0;
}
/**
* this gets the opcode from a packet
*/
int16_t get_type(artnet_packet p) {
uint8_t *data;
if (p->length < 10)
return 0;
if (!memcmp(&p->data, "Art-Net\0", 8)) {
// not the best here, this needs to be tested on different arch
data = (uint8_t *) &p->data;
p->type = (data[9] << 8) + data[8];
return p->type;
} else {
return 0;
}
}
/*
* takes a subnet and an address and creates the universe address
*/
uint8_t _make_addr(uint8_t subnet, uint8_t addr) {
return ((subnet & LOW_NIBBLE) << 4) | (addr & LOW_NIBBLE);
}
/*
*
*/
void check_merge_timeouts(node n, int port_id) {
output_port_t *port;
time_t now;
time_t timeoutA, timeoutB;
port = &n->ports.out[port_id];
time(&now);
timeoutA = now - port->timeA;
timeoutB = now - port->timeB;
if (timeoutA > MERGE_TIMEOUT_SECONDS) {
// A is old, stop the merge
port->ipA.s_addr = 0;
}
if (timeoutB > MERGE_TIMEOUT_SECONDS) {
// B is old, stop the merge
port->ipB.s_addr = 0;
}
}
/*
* merge the data from two sources
*/
void merge(node n, int port_id, int length, uint8_t *latest) {
int i;
output_port_t *port;
port = &n->ports.out[port_id];
if (port->merge_mode == ARTNET_MERGE_HTP) {
for (i=0; i< length; i++)
port->data[i] = max(port->dataA[i], port->dataB[i]);
} else {
memcpy(port->data, latest, length);
}
}
void reset_firmware_upload(node n) {
n->firmware.bytes_current = 0;
n->firmware.bytes_total = 0;
n->firmware.peer.s_addr = 0;
n->firmware.ubea = 0;
n->firmware.last_time = 0;
free(n->firmware.data);
}
Reference in New Issue View Git Blame Copy Permalink