/* returns error, zero is good */
static int g_tcp_bind_flags(int sck, const char* port, const char* address, int flags)
{
int error;
int status;
struct addrinfo* res;
struct addrinfo hints = { 0 };
status = -1;
g_memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_flags = flags;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
error = getaddrinfo(NULL, port, &hints, &res);
if (error == 0)
{
while ((res != 0) && (status < 0))
{
if (address_match(address, res))
{
status = bind(sck, res->ai_addr, res->ai_addrlen);
}
res = res->ai_next;
}
}
return status;
}
void My_Write_Property_SimpleAck_Handler(
BACNET_ADDRESS * src,
uint8_t invoke_id)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
__LogAnswer("WriteProperty Acknowledged!", 0);
}
}
void MyWritePropertySimpleAckHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
printf("\nWriteProperty Acknowledged!\n");
}
}
void My_Write_Property_Ack_Handler(
BACNET_ADDRESS * src,
uint8_t invoke_id)
{
if (address_match(&target_address, src) &&
(invoke_id == request_invoke_id)) {
printf("\r\nWriteProperty Acknowledged!\r\n");
write_acked = 1;
}
}
void MyRejectHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t reject_reason)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
printf("BACnet Reject: %s\r\n",
bactext_reject_reason_name((int) reject_reason));
Error_Detected = true;
}
}
void MyRejectHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t reject_reason)
{
if (address_match(&target_address, src) &&
(invoke_id == request_invoke_id)) {
printf("BACnet Reject: %s\r\n",
bactext_reject_reason_name((int) reject_reason));
error_detected = TRUE;
}
}
static void MyRejectHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t reject_reason)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
char msg[MAX_ERROR_STRING];
sprintf(msg, "BACnet Reject: %s",
bactext_reject_reason_name((int) reject_reason));
LogError(msg);
}
}
void MyAbortHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t abort_reason,
bool server)
{
(void) server;
if (address_match(&target_address, src) &&
(invoke_id == request_invoke_id)) {
printf("BACnet Abort: %s\r\n",
bactext_abort_reason_name((int) abort_reason));
error_detected = TRUE;
}
}
static void Atomic_Write_File_Error_Handler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
BACNET_ERROR_CLASS error_class,
BACNET_ERROR_CODE error_code)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Current_Invoke_ID)) {
printf("\r\nBACnet Error!\r\n");
printf("Error Class: %s\r\n", bactext_error_class_name(error_class));
printf("Error Code: %s\r\n", bactext_error_code_name(error_code));
Error_Detected = true;
}
}
static void MyErrorHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
BACNET_ERROR_CLASS error_class,
BACNET_ERROR_CODE error_code)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
printf("BACnet Error: %s: %s\r\n",
bactext_error_class_name((int) error_class),
bactext_error_code_name((int) error_code));
Error_Detected = true;
}
}
void MyAbortHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t abort_reason,
bool server)
{
(void) server;
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
printf("BACnet Abort: %s\r\n",
bactext_abort_reason_name((int) abort_reason));
Error_Detected = true;
}
}
static void MyAbortHandler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
uint8_t abort_reason,
bool server)
{
(void) server;
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
char msg[MAX_ERROR_STRING];
sprintf(msg, "BACnet Abort: %s",
bactext_abort_reason_name((int) abort_reason));
LogError(msg);
}
}
static void My_Error_Handler(
BACNET_ADDRESS * src,
uint8_t invoke_id,
BACNET_ERROR_CLASS error_class,
BACNET_ERROR_CODE error_code)
{
if (address_match(&Target_Address, src) &&
(invoke_id == Request_Invoke_ID)) {
char msg[MAX_ERROR_STRING];
sprintf(msg, "BACnet Error: %s: %s",
bactext_error_class_name((int) error_class),
bactext_error_code_name((int) error_code));
LogError(msg);
}
}
/** Handler for a ReadProperty ACK.
* @ingroup DSRP
* Doesn't actually do anything, except, for debugging, to
* print out the ACK data of a matching request.
*
* @param service_request [in] The contents of the service request.
* @param service_len [in] The length of the service_request.
* @param src [in] BACNET_ADDRESS of the source of the message
* @param service_data [in] The BACNET_CONFIRMED_SERVICE_DATA information
* decoded from the APDU header of this message.
*/
static void My_Read_Property_Ack_Handler(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
{
int len = 0;
BACNET_READ_PROPERTY_DATA data;
if (address_match(&Target_Address, src) &&
(service_data->invoke_id == Request_Invoke_ID)) {
len =
rp_ack_decode_service_request(service_request, service_len, &data);
if (len > 0) {
rp_ack_extract_data(&data);
}
}
}
void My_Read_Property_Ack_Handler(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
{
int len = 0;
BACNET_READ_PROPERTY_DATA data;
if (address_match(&target_address, src) &&
(service_data->invoke_id == request_invoke_id)) {
len =
rp_ack_decode_service_request(service_request, service_len,
&data);
if (len < 0) {
printf("<decode failed!>\r\n");
} else {
rp_ack_sprintf_data(value, (size_t) value_length,&data);
}
}
}
static void AtomicReadFileAckHandler(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
{
int len = 0;
BACNET_ATOMIC_READ_FILE_DATA data;
if (address_match(&Target_Address, src) &&
(service_data->invoke_id == Request_Invoke_ID)) {
len =
arf_ack_decode_service_request(service_request, service_len,
&data);
if (len > 0) {
/* validate the parameters before storing data */
if ((data.access == FILE_STREAM_ACCESS) &&
(service_data->invoke_id == Request_Invoke_ID)) {
char msg[32];
uint8_t *pFileData;
int i;
sprintf(msg, "EOF=%d,start=%d,", data.endOfFile,
data.type.stream.fileStartPosition);
__LogAnswer(msg, 0);
pFileData = octetstring_value(&data.fileData);
for (i = 0; i < octetstring_length(&data.fileData); i++) {
sprintf(msg, "%02x ", *pFileData);
__LogAnswer(msg, 1);
pFileData++;
}
} else {
LogError("Bad stream access reported");
}
}
}
}
/* Does the given string contain an address configured as one of the
* user's "primary" or "other" addresses. If so, return the matching
* address, NULL otherwise. */
static const char *
user_address_in_string (const char *str, notmuch_config_t *config)
{
return address_match (str, config, USER_ADDRESS_IN_STRING);
}
/* Do any of the addresses configured as one of the user's "primary"
* or "other" addresses contain the given string. If so, return the
* matching address, NULL otherwise. */
static const char *
string_in_user_address (const char *str, notmuch_config_t *config)
{
return address_match (str, config, STRING_IN_USER_ADDRESS);
}
/** Handler for a ReadPropertyMultiple ACK.
* @ingroup DSRPM
* For each read property, print out the ACK'd data,
* and free the request data items from linked property list.
*
* @param service_request [in] The contents of the service request.
* @param service_len [in] The length of the service_request.
* @param src [in] BACNET_ADDRESS of the source of the message
* @param service_data [in] The BACNET_CONFIRMED_SERVICE_DATA information
* decoded from the APDU header of this message.
*/
static void My_Read_Property_Multiple_Ack_Handler(
uint8_t * service_request,
uint16_t service_len,
BACNET_ADDRESS * src,
BACNET_CONFIRMED_SERVICE_ACK_DATA * service_data)
{
int len = 0;
BACNET_READ_ACCESS_DATA *rpm_data;
BACNET_READ_ACCESS_DATA *old_rpm_data;
BACNET_PROPERTY_REFERENCE *rpm_property;
BACNET_PROPERTY_REFERENCE *old_rpm_property;
BACNET_APPLICATION_DATA_VALUE *value;
BACNET_APPLICATION_DATA_VALUE *old_value;
if (address_match(&Target_Address, src) &&
(service_data->invoke_id == Request_Invoke_ID)) {
rpm_data = calloc(1, sizeof(BACNET_READ_ACCESS_DATA));
if (rpm_data) {
len =
rpm_ack_decode_service_request(service_request, service_len,
rpm_data);
}
if (len > 0) {
while (rpm_data) {
rpm_ack_extract_data(rpm_data);
rpm_property = rpm_data->listOfProperties;
while (rpm_property) {
value = rpm_property->value;
while (value) {
old_value = value;
value = value->next;
free(old_value);
}
old_rpm_property = rpm_property;
rpm_property = rpm_property->next;
free(old_rpm_property);
}
old_rpm_data = rpm_data;
rpm_data = rpm_data->next;
free(old_rpm_data);
}
} else {
LogError("RPM Ack Malformed! Freeing memory...");
while (rpm_data) {
rpm_property = rpm_data->listOfProperties;
while (rpm_property) {
value = rpm_property->value;
while (value) {
old_value = value;
value = value->next;
free(old_value);
}
old_rpm_property = rpm_property;
rpm_property = rpm_property->next;
free(old_rpm_property);
}
old_rpm_data = rpm_data;
rpm_data = rpm_data->next;
free(old_rpm_data);
}
}
}
}
/* Is the given address configured as one of the user's "primary" or
* "other" addresses. */
static notmuch_bool_t
address_is_users (const char *address, notmuch_config_t *config)
{
return address_match (address, config, STRING_IS_USER_ADDRESS) != NULL;
}
/* The main function -- deal with a packet. */
int
handle_packet(int sock, unsigned char *packet, int packetlen,
struct interface *interface, struct in6_addr *from)
{
int bodylen, length, i;
struct in6_addr nexthop;
int have_nexthop = 0;
if(!linklocal(from)) {
fprintf(stderr, "Received non-link-local packet.\n");
return -1;
}
if(packetlen < 4 || packet[0] != 42 || packet[1] != 2)
goto fail;
DO_NTOHS(bodylen, packet + 2);
if(bodylen + 4 > packetlen)
goto fail;
i = 0;
while(i < bodylen) {
unsigned char *tlv = packet + 4 + i;
unsigned int type;
type = tlv[0];
if(type == MESSAGE_PAD1) {
i++;
continue;
}
if(i + 1 > bodylen)
goto fail;
length = tlv[1];
if(i + length > bodylen)
goto fail;
#define CHECK(l) do { if(length + 2 < l) goto fail; } while(0)
switch(type) {
case MESSAGE_ACK_REQ:
CHECK(8);
send_ack(sock, interface, from, tlv + 4);
break;
case MESSAGE_HELLO: {
unsigned short interval;
CHECK(8);
DO_NTOHS(interval, tlv + 6);
update_neighbour(from, interface, 0, interval);
break;
}
case MESSAGE_IHU:
CHECK(8);
if(tlv[2] == AE_WILDCARD ||
(tlv[2] == AE_LL && length + 2 >= 16 &&
address_match(tlv + 8, interface))) {
unsigned short rxcost;
DO_NTOHS(rxcost, tlv + 4);
update_neighbour(from, interface, 1, rxcost);
}
break;
case MESSAGE_NH:
CHECK(4);
if(tlv[2] == AE_LL) {
unsigned char ll[8] = {0xfe, 0x80, 0, 0, 0, 0, 0, 0};
CHECK(12);
memcpy((unsigned char*)&nexthop, ll, 8);
memcpy(((unsigned char*)&nexthop) + 8, tlv + 4, 8);
have_nexthop = 1;
}
break;
case MESSAGE_UPDATE:
CHECK(12);
/* We're only interested in IPv6 default routes. */
if(tlv[2] == AE_IPV6 && tlv[4] == 0) {
unsigned short interval, metric;
DO_NTOHS(interval, tlv + 6);
DO_NTOHS(metric, tlv + 10);
update_selected_route(interface,
have_nexthop ? &nexthop : from,
interval, metric);
}
break;
case MESSAGE_REQUEST:
CHECK(4);
if(tlv[2] == AE_WILDCARD) {
/* Request for a full table dump. */
send_update(sock, interface, 0);
} else if(tlv[2] == AE_IPV6 && tlv[3] == 64) {
/* Request for a specific /64. Is it ours? */
CHECK(12);
if(have_prefix && memcmp(myprefix, tlv + 4, 8) == 0)
send_update(sock, interface, 0);
}
break;
case MESSAGE_MH_REQUEST:
CHECK(16);
/* There's no such thing as a wildcard multi-hop request. */
if(tlv[2] == AE_IPV6 && tlv[3] == 64) {
unsigned int seqno;
DO_NTOHS(seqno, tlv + 4);
if(have_prefix &&
tlv[3] == 6 && memcmp(myprefix, tlv + 8, 8) == 0 &&
memcmp(tlv + 8, my_router_id, 8) == 0) {
increment_myseqno(seqno);
send_update(sock, interface, 0);
}
}
break;
default:
/* We're ignoring all other TLVs. */
break;
}
i += length + 2;
}
return 1;
fail:
fprintf(stderr, "Received malformed packet.\n");
return -1;
}
