GitHub/zTC1
1
0
Fork 0
mirror of https://github.com/oopuuu/zTC1.git synced 2025-12-15 22:48:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

修改了Web后台的部分界面，增加了HAmqtt中的总电量传感器，后台新增mqtt上报频率设置

Browse Source
This commit is contained in:
OOP
2025-03-03 21:49:41 +08:00
parent e1e00b60ce
commit 9f9d4c7a56
4468 changed files with 1473046 additions and 10728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

890
mico-os/MiCO/system/mdns/mico_mdns.c Normal file
View File

@@ -0,0 +1,890 @@
/**
******************************************************************************
* @file mico_mdns.c
* @author William Xu
* @version V1.0.0
* @date 05-May-2014
* @brief This header contains function called by mdns protocol operation
******************************************************************************
* UNPUBLISHED PROPRIETARY SOURCE CODE
* Copyright (c) 2016 MXCHIP Inc.
*
* The contents of this file may not be disclosed to third parties, copied or
* duplicated in any form, in whole or in part, without the prior written
* permission of MXCHIP Corporation.
******************************************************************************
*/
#include "mico_mdns.h"
#include "StringUtils.h"
#include "SocketUtils.h"
/** "224.0.0.251" */
#define INADDR_MULTICAST_MDNS ((uint32_t)0xE00000FBUL)
static int mDNS_fd = -1;
static bool bonjour_instance = false;
typedef struct
{
char* hostname;
char* instance_name;
char* service_name;
char* txt_att;
char instance_name_suffix[4];
WiFi_Interface interface;
uint32_t ttl;
uint16_t port;
uint8_t count_down;
mdns_record_state_t state;
} dns_sd_service_record_t;
#define APP_Available_Offset 0
#define Support_TLV_Config_Offset 2
#define Problem_Detected_Offset 0
#define Not_Configured_Offset 1
#define SERVICE_QUERY_NAME "_services._dns-sd._udp.local."
//#define mdns_utils_log(M, ...) custom_log("mDNS Utils", M, ##__VA_ARGS__)
//#define mdns_utils_log_trace() custom_log_trace("mDNS Utils")
#define mdns_utils_log(M, ...)
#define mdns_utils_log_trace()
static dns_sd_service_record_t available_services[ MAX_RECORD_COUNT ];
static uint8_t available_service_count = MAX_RECORD_COUNT;
static int dns_get_next_question( dns_message_iterator_t* iter, dns_question_t* q, dns_name_t* name );
static int dns_compare_name_to_string( dns_name_t* name, const char* string );
static int dns_create_message( dns_message_iterator_t* message, uint16_t size );
static void dns_write_header( dns_message_iterator_t* iter, uint16_t id, uint16_t flags, uint16_t question_count, uint16_t answer_count, uint16_t authorative_count );
static void dns_write_record( dns_message_iterator_t* iter, const char* name, uint16_t record_class, uint16_t record_type, uint32_t ttl, uint8_t* rdata );
static void mdns_send_message(int fd, dns_message_iterator_t* message );
static void dns_free_message( dns_message_iterator_t* message );
static void mdns_process_query(int fd, dns_name_t* name, dns_question_t* question, dns_message_iterator_t* source );
static void dns_write_record( dns_message_iterator_t* iter, const char* name, uint16_t record_class, uint16_t record_type, uint32_t ttl, uint8_t* rdata );
static void dns_write_uint16( dns_message_iterator_t* iter, uint16_t data );
static void dns_write_uint32( dns_message_iterator_t* iter, uint32_t data );
static void dns_write_bytes( dns_message_iterator_t* iter, uint8_t* data, uint16_t length );
static uint16_t dns_read_uint16( dns_message_iterator_t* iter );
static void dns_skip_name( dns_message_iterator_t* iter );
static void dns_write_name( dns_message_iterator_t* iter, const char* src );
static OSStatus start_bonjour_service(void);
static mico_mutex_t bonjour_mutex = NULL;
static mico_semaphore_t update_state_sem = NULL;
static int update_state_fd = 0;
static mico_thread_t mfi_bonjour_thread_handler;
static void _bonjour_thread(uint32_t arg);
void process_dns_questions(int fd, dns_message_iterator_t* iter )
{
dns_name_t name;
dns_question_t question;
dns_message_iterator_t response;
IPStatusTypedef para;
int a = 0;
int question_processed;
uint32_t myip;
memset( &response, 0, sizeof(dns_message_iterator_t) );
for ( a = 0; a < htons(iter->header->question_count); ++a )
{
if (iter->iter > iter->end)
break;
if(dns_get_next_question( iter, &question, &name )==0)
break;
question_processed = 0;
switch ( question.question_type ){
case RR_TYPE_PTR:
if ( available_services != NULL ){
// Check if its a query for all available services
if ( dns_compare_name_to_string( &name, SERVICE_QUERY_NAME ) ){
int b = 0;
if(dns_create_message( &response, 512 )) {
dns_write_header(&response, iter->header->id, 0x8400, 0, available_service_count, 0 );
for ( b = 0; b < available_service_count; ++b ){
dns_write_record( &response, SERVICE_QUERY_NAME, RR_CLASS_IN, RR_TYPE_PTR, 1500, (uint8_t*) available_services[b].service_name );
}
mdns_send_message(fd, &response );
dns_free_message( &response );
question_processed = 1;
}
}
// else check if its one of our records
else {
int b = 0;
for ( b = 0; b < available_service_count; ++b ){
//printf("UDP multicast test: Recv a SERVICE Detail request: %s.\r\n", name);
if ( dns_compare_name_to_string( &name, available_services[b].service_name )){
if( available_services[b].state != RECORD_NORMAL )
continue;
micoWlanGetIPStatus(&para, available_services[b].interface);
myip = inet_addr(para.ip);
if( myip == 0 || myip == 0xFFFFFFFF) continue;
// Send the PTR, TXT, SRV and A records
if(dns_create_message( &response, 512 )){
dns_write_header( &response, iter->header->id, 0x8400, 0, 4, 0 );
//dns_write_record( &response, MFi_SERVICE_QUERY_NAME, RR_CLASS_IN, RR_TYPE_PTR, 1500, (u8*) available_services[b].service_name );
dns_write_record( &response, available_services[b].service_name, RR_CLASS_IN, RR_TYPE_PTR, available_services[b].ttl, (uint8_t*) available_services[b].instance_name );
dns_write_record( &response, available_services[b].instance_name, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_TXT, available_services[b].ttl, (uint8_t*) available_services[b].txt_att );
dns_write_record( &response, available_services[b].instance_name, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_SRV, available_services[b].ttl, (uint8_t*) &available_services[b]);
dns_write_record( &response, available_services[b].hostname, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_A, available_services[b].ttl, (uint8_t*) &myip);
mdns_send_message(fd, &response );
dns_free_message( &response );
question_processed = 1;
}
}
}
}
}
break;
}
if (!question_processed ){
mdns_process_query(fd, &name, &question, iter);
}
}
}
static void mdns_process_query(int fd, dns_name_t* name,
dns_question_t* question, dns_message_iterator_t* source )
{
dns_message_iterator_t response;
IPStatusTypedef para;
uint32_t myip;
int b = 0;
memset( &response, 0, sizeof(dns_message_iterator_t) );
switch ( question->question_type )
{
case RR_QTYPE_ANY:
case RR_TYPE_A:
for ( b = 0; b < available_service_count; ++b ){
if ( dns_compare_name_to_string( name, available_services[b].hostname ) ){
micoWlanGetIPStatus(&para, available_services[b].interface);
myip = inet_addr(para.ip);
if( myip == 0 || myip == 0xFFFFFFFF) continue;
if(dns_create_message( &response, 256 )){
dns_write_header( &response, source->header->id, 0x8400, 0, 1, 0 );
dns_write_record( &response, available_services[b].hostname, RR_CLASS_IN | RR_CACHE_FLUSH, RR_TYPE_A, available_services[b].ttl, (uint8_t *)&myip);
mdns_send_message(fd, &response );
dns_free_message( &response );
return;
}
}
}
default:
break;;
}
}
static int dns_get_next_question( dns_message_iterator_t* iter, dns_question_t* q, dns_name_t* name )
{
// Set the name pointers and then skip it
name->start_of_name = (uint8_t*) iter->iter;
name->start_of_packet = (uint8_t*) iter->header;
dns_skip_name( iter );
if (iter->iter > iter->end)
return 0;
// Read the type and class
q->question_type = dns_read_uint16( iter );
q->question_class = dns_read_uint16( iter );
return 1;
}
static int dns_compare_name_to_string( dns_name_t* name, const char* string )
{
uint8_t section_length;
int finished = 0;
int result = 1;
uint8_t* buffer = name->start_of_name;
char *temp;
while ( !finished )
{
// Check if the name is compressed. If so, find the uncompressed version
while ( (uint8_t)(*buffer) & 0xC0 )
{
uint16_t offset = ( *buffer++ ) << 8;
offset += *buffer;
offset &= 0x3FFF;
buffer = name->start_of_packet + offset;
}
// Compare section
section_length = *( buffer++ );
temp = malloc(section_length+1);
temp[section_length] = 0;
memcpy(temp, buffer, section_length );
free(temp);
if ( strncmp( (char*) buffer, string, section_length ) )
{
result = 0;
finished = 1;
}
string += section_length + 1;
buffer += section_length;
// Check if we've finished comparing
if ( *buffer == 0 || *string == 0 )
{
finished = 1;
// Check if one of the strings has more data
if ( *buffer != 0 || *string != 0 )
{
result = 0;
}
}
}
return result;
}
static int dns_create_message( dns_message_iterator_t* message, uint16_t size )
{
message->header = (dns_message_header_t*) malloc( size );
if ( message->header == NULL )
{
return 0;
}
message->iter = (uint8_t *) message->header + sizeof(dns_message_header_t);
return 1;
}
static void dns_free_message( dns_message_iterator_t* message )
{
free(message->header);
message->header = NULL;
}
static void dns_write_string( dns_message_iterator_t* iter, const char* src )
{
uint8_t* segment_length_pointer;
uint8_t segment_length;
while ( *src != 0 && (uint8_t)(*src) != 0xC0)
{
/* Remember where we need to store the segment length and reset the counter*/
segment_length_pointer = iter->iter++;
segment_length = 0;
/* Copy bytes until '.' or end of string*/
while ( *src != '.' && *src != 0 && (uint8_t)(*src) != 0xC0)
{
if (*src == '/')
src++; // skip '/'
*iter->iter++ = *src++;
++segment_length;
}
/* Store the length of the segment*/
*segment_length_pointer = segment_length;
/* Check if we stopped because of a '.', if so, skip it*/
if ( *src == '.' )
{
++src;
}
}
if ( (uint8_t)(*src) == 0xC0) { // compress name
*iter->iter++ = *src++;
*iter->iter++ = *src++;
} else {
/* Add the ending null */
*iter->iter++ = 0;
}
}
static void dns_write_header( dns_message_iterator_t* iter, uint16_t id, uint16_t flags, uint16_t question_count, uint16_t answer_count, uint16_t authorative_count )
{
memset( iter->header, 0, sizeof(dns_message_header_t) );
iter->header->id = htons(id);
iter->header->flags = htons(flags);
iter->header->question_count = htons(question_count);
iter->header->name_server_count = htons(authorative_count);
iter->header->answer_count = htons(answer_count);
}
static void dns_write_record( dns_message_iterator_t* iter, const char* name, uint16_t record_class, uint16_t record_type, uint32_t ttl, uint8_t* rdata )
{
uint8_t* rd_length;
uint8_t* temp_ptr;
/* Write the name, type, class, TTL*/
dns_write_name ( iter, name );
dns_write_uint16( iter, record_type );
dns_write_uint16( iter, record_class );
dns_write_uint32( iter, ttl );
/* Keep track of where we store the rdata length*/
rd_length = iter->iter;
iter->iter += 2;
temp_ptr = iter->iter;
switch ( record_type )
{
case RR_TYPE_A:
dns_write_bytes( iter, rdata, 4 );
break;
case RR_TYPE_PTR:
case RR_TYPE_TXT:
dns_write_name( iter, (const char*) rdata );
break;
case RR_TYPE_SRV:
/* Set priority and weight to 0*/
dns_write_uint16( iter, 0 );
dns_write_uint16( iter, 0 );
/* Write the port*/
dns_write_uint16( iter, ( (dns_sd_service_record_t*) rdata )->port );
/* Write the hostname*/
dns_write_string( iter, ( (dns_sd_service_record_t*) rdata )->hostname );
break;
default:
break;
}
// Write the rdata length
rd_length[0] = ( iter->iter - temp_ptr ) >> 8;
rd_length[1] = ( iter->iter - temp_ptr ) & 0xFF;
}
static void mdns_send_message(int fd, dns_message_iterator_t* message )
{
struct sockaddr_in addr;
// printf("enter send message\r\n");
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_MULTICAST_MDNS);
addr.sin_port = htons(5353);
sendto(fd, message->header, message->iter - (uint8_t*)message->header, 0, (struct sockaddr *)&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
addr.sin_port = htons(INADDR_BROADCAST);
sendto(fd, message->header, message->iter - (uint8_t*)message->header, 0, (struct sockaddr *)&addr, sizeof(addr));
}
static void dns_write_uint16( dns_message_iterator_t* iter, uint16_t data )
{
// We cannot assume the u8 alignment of iter->iter so we can't just typecast and assign
iter->iter[0] = data >> 8;
iter->iter[1] = data & 0xFF;
iter->iter += 2;
}
static void dns_write_uint32( dns_message_iterator_t* iter, uint32_t data )
{
iter->iter[0] = data >> 24;
iter->iter[1] = data >> 16;
iter->iter[2] = data >> 8;
iter->iter[3] = data & 0xFF;
iter->iter += 4;
}
static void dns_write_bytes( dns_message_iterator_t* iter, uint8_t* data, uint16_t length )
{
int a = 0;
for ( a = 0; a < length; ++a )
{
iter->iter[a] = data[a];
}
iter->iter += length;
}
static uint16_t dns_read_uint16( dns_message_iterator_t* iter )
{
uint16_t temp = (uint16_t) ( *iter->iter++ ) << 8;
temp += (uint16_t) ( *iter->iter++ );
return temp;
}
static void dns_skip_name( dns_message_iterator_t* iter )
{
while ( *iter->iter != 0 )
{
// Check if the name is compressed
if ( *iter->iter & 0xC0 )
{
iter->iter += 1; // Normally this should be 2, but we have a ++ outside the while loop
break;
}
else
{
iter->iter += (uint32_t) *iter->iter + 1;
}
if (iter->iter > iter->end)
break;
}
// Skip the null u8
++iter->iter;
}
static void dns_write_name( dns_message_iterator_t* iter, const char* src )
{
dns_write_string( iter, src );
}
static bool is_service_match ( dns_sd_service_record_t *record, char *service_name, WiFi_Interface interface )
{
if( record->state == RECORD_REMOVED || record->state == RECORD_REMOVE )
return false;
if( ( service_name == NULL || strcmp( record->service_name, service_name ) == 0 ) && record->interface == interface )
return true;
return false;
}
static int find_record_by_service ( char *service_name, WiFi_Interface interface )
{
int i;
uint32_t insert_index = 0xFF;
for ( i = 0; i < available_service_count; i++ ){
if( is_service_match ( &available_services[i], service_name, interface ) ){
insert_index = i;
break;
}
}
return insert_index;
}
static int find_empty_record ( void )
{
int i;
uint32_t insert_index = 0xFF;
for ( i = 0; i < available_service_count; i++ ){
if( available_services[i].state == RECORD_REMOVED ){
insert_index = i;
break;
}
}
return insert_index;
}
static mico_thread_t _bonjour_announce_handler = NULL;
void _bonjour_send_anounce_thread(uint32_t arg)
{
uint32_t insert_index = 0xFF;
UNUSED_PARAMETER( arg );
while(1){
insert_index = 0xFF;
for ( int i = 0; i < available_service_count; i++ ){
if( available_services[i].state != RECORD_REMOVED && available_services[i].count_down != 0 ){
insert_index = i;
break;
}
}
if( insert_index == 0xFF )
goto exit;
mdns_utils_log( "sem trigger" );
mico_rtos_set_semaphore( &update_state_sem );
mico_thread_msleep(200);
}
exit:
_bonjour_announce_handler = NULL;
mico_rtos_delete_thread( NULL );
return;
}
static void _clean_record_resource( dns_sd_service_record_t *record )
{
if(record->service_name) {
free(record->service_name);
record->service_name = NULL;
}
if(record->hostname){
free(record->hostname);
record->hostname = NULL;
}
if(record->instance_name){
free(record->instance_name);
record->instance_name = NULL;
}
if(record->txt_att){
free(record->txt_att);
record->txt_att = NULL;
}
}
OSStatus mdns_add_record( mdns_init_t init, WiFi_Interface interface, uint32_t time_to_live )
{
int len;
OSStatus err = kNoErr;
uint32_t insert_index = 0xFF;
if( bonjour_instance == false ){
err = start_bonjour_service( );
require_noerr(err, exit);
}
insert_index = find_record_by_service ( init.service_name, interface );
if( insert_index == 0xFF)
insert_index = find_empty_record ( );
require_action( insert_index < available_service_count, exit, err = kNoResourcesErr);
mico_rtos_lock_mutex( &bonjour_mutex );
_clean_record_resource( &available_services[insert_index] );
available_services[insert_index].interface = interface;
available_services[insert_index].service_name = (char*)__strdup(init.service_name);
available_services[insert_index].hostname = (char*)__strdup(init.host_name);
len = strlen(init.instance_name);
available_services[insert_index].instance_name = (char*)malloc(len+3);//// 0xc00c+\0
memcpy(available_services[insert_index].instance_name, init.instance_name, len);
available_services[insert_index].instance_name[len]= 0xc0;
available_services[insert_index].instance_name[len+1]= 0x0c;
available_services[insert_index].instance_name[len+2]= 0;
available_services[insert_index].txt_att = (char*)__strdup(init.txt_record);
available_services[insert_index].port = init.service_port;
available_services[insert_index].state = RECORD_UPDATE;
available_services[insert_index].count_down = 5;
available_services[insert_index].ttl = time_to_live;
if( _bonjour_announce_handler == NULL)
mico_rtos_create_thread( &_bonjour_announce_handler, MICO_APPLICATION_PRIORITY, "Bonjour Announce", _bonjour_send_anounce_thread, 0x400, 0 );
mico_rtos_unlock_mutex( &bonjour_mutex );
exit:
return err;
}
void mdns_update_txt_record( char *service_name, WiFi_Interface interface, char *txt_record )
{
uint32_t insert_index = 0xFF;
if( bonjour_instance == false ) return;
insert_index = find_record_by_service ( service_name, interface );
if( insert_index == 0xFF ) return;
mico_rtos_lock_mutex( &bonjour_mutex );
if(available_services[insert_index].txt_att) free(available_services[insert_index].txt_att);
available_services[insert_index].txt_att = (char*)__strdup(txt_record);
available_services[insert_index].state = RECORD_UPDATE;
available_services[insert_index].count_down = 5;
if( _bonjour_announce_handler == NULL)
mico_rtos_create_thread( &_bonjour_announce_handler, MICO_APPLICATION_PRIORITY, "Bonjour Announce", _bonjour_send_anounce_thread, 0x400, 0 );
mico_rtos_unlock_mutex( &bonjour_mutex );
}
void mdns_suspend_record( char *service_name, WiFi_Interface interface, bool will_remove )
{
int i;
uint32_t insert_index = 0xFF;
mdns_utils_log( "Suspend %s@%d", service_name == NULL ? "null" : service_name, interface);
if( bonjour_instance == false ) return;
mico_rtos_lock_mutex( &bonjour_mutex );
for ( i = 0; i < available_service_count; i++ ){
if( is_service_match ( &available_services[i], service_name, interface ) == false)
continue;
mdns_utils_log( "Find index %d to suspend", i);
if( will_remove == true )
available_services[i].state = RECORD_REMOVE;
else{
if( available_services[i].state != RECORD_REMOVE )
available_services[i].state = RECORD_SUSPEND;
}
available_services[i].count_down = 5;
insert_index = i;
}
if( insert_index == 0xFF )
goto exit;
if( _bonjour_announce_handler == NULL)
mico_rtos_create_thread( &_bonjour_announce_handler, MICO_APPLICATION_PRIORITY, "Bonjour Announce", _bonjour_send_anounce_thread, 0x400, 0 );
exit:
mico_rtos_unlock_mutex( &bonjour_mutex );
return;
}
void mdns_resume_record( char *service_name, WiFi_Interface interface )
{
int i;
uint32_t insert_index = 0xFF;
if( bonjour_instance == false ) return;
mico_rtos_lock_mutex( &bonjour_mutex );
for ( i = 0; i < available_service_count && is_service_match( &available_services[i], service_name, interface ); i++ ){
available_services[i].state = RECORD_UPDATE;
available_services[i].count_down = 5;
insert_index = i;
}
if( insert_index == 0xFF )
goto exit;
if( _bonjour_announce_handler == NULL)
mico_rtos_create_thread( &_bonjour_announce_handler, MICO_APPLICATION_PRIORITY, "Bonjour Announce", _bonjour_send_anounce_thread, 0x400, 0 );
exit:
mico_rtos_unlock_mutex( &bonjour_mutex );
return;
}
mdns_record_state_t mdns_get_record_status( char *service_name, WiFi_Interface interface)
{
uint32_t insert_index = find_record_by_service( service_name, interface );
if( insert_index == 0xFF ) return RECORD_REMOVED;
return available_services[insert_index].state;
}
void mdns_handler(int fd, uint8_t* pkt, int pkt_len)
{
dns_message_iterator_t iter;
iter.header = (dns_message_header_t*) pkt;
iter.iter = (uint8_t*) iter.header + sizeof(dns_message_header_t);
iter.end = pkt+pkt_len;
// Check if the message is a response (otherwise its a query)
if ( ntohs(iter.header->flags) & DNS_MESSAGE_IS_A_RESPONSE )
{
}
else
{
process_dns_questions(fd, &iter );
}
}
void bonjour_send_record(int record_index)
{
dns_message_iterator_t response;
uint32_t myip;
IPStatusTypedef para;
int ttl = 0;
/* Send service and a ttl > 0 for a working record*/
if( available_services[record_index].state == RECORD_NORMAL || available_services[record_index].state == RECORD_UPDATE ){
ttl = available_services[record_index].ttl;
if(dns_create_message( &response, 512 )) {
dns_write_header(&response, 0x0, 0x8400, 0, 1, 0 );
dns_write_record( &response, SERVICE_QUERY_NAME, RR_CLASS_IN, RR_TYPE_PTR, 1500, (uint8_t*) available_services[record_index].service_name );
mdns_send_message(mDNS_fd, &response );
dns_free_message( &response );
}
}
micoWlanGetIPStatus(&para, available_services[record_index].interface);
myip = inet_addr(para.ip);
if( myip == 0 || myip == 0xFFFFFFFF) return;
if(dns_create_message( &response, 512 )){
mdns_utils_log( "TTL = %d", ttl);
micoWlanGetIPStatus(&para, available_services[record_index].interface);
dns_write_header( &response, 0x0, 0x8400, 0, 4, 0 );
dns_write_record( &response, available_services[record_index].service_name, RR_CLASS_IN, RR_TYPE_PTR, ttl, (uint8_t*) available_services[record_index].instance_name );
dns_write_record( &response, available_services[record_index].instance_name, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_TXT, ttl, (uint8_t*) available_services[record_index].txt_att );
dns_write_record( &response, available_services[record_index].instance_name, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_SRV, ttl, (uint8_t*) &available_services[record_index]);
dns_write_record( &response, available_services[record_index].hostname, RR_CACHE_FLUSH|RR_CLASS_IN, RR_TYPE_A, ttl, (uint8_t*) &myip);
mdns_send_message(mDNS_fd, &response );
dns_free_message( &response );
}
}
void BonjourNotify_WifiStatusHandler( WiFiEvent event, void *arg )
{
UNUSED_PARAMETER(arg);
switch (event) {
case NOTIFY_STATION_UP:
mdns_resume_record( NULL, Station );
break;
case NOTIFY_STATION_DOWN:
mdns_suspend_record( NULL, Station, false );
break;
case NOTIFY_AP_UP:
mdns_resume_record( NULL, Soft_AP );
break;
case NOTIFY_AP_DOWN:
mdns_suspend_record( NULL, Soft_AP, false );
break;
default:
break;
}
return;
}
void BonjourNotify_SYSWillPoerOffHandler( void *arg )
{
UNUSED_PARAMETER(arg);
mdns_suspend_record( NULL, Station, true );
mdns_suspend_record( NULL, Soft_AP, true );
}
uint8_t *buf = NULL;
static OSStatus start_bonjour_service(void)
{
OSStatus err = kNoErr;
struct sockaddr_in addr;
ip_mreq mreq_opt;
if(bonjour_mutex == NULL)
mico_rtos_init_mutex( &bonjour_mutex );
if(update_state_sem == NULL)
mico_rtos_init_semaphore( &update_state_sem, 1 );
update_state_fd = mico_create_event_fd( update_state_sem );
memset( available_services, 0x0, sizeof( available_services ) );
buf = malloc(1500);
require_action(buf, exit, err =kNoMemoryErr);
mDNS_fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
require_action(IsValidSocket( mDNS_fd ), exit, err = kNoResourcesErr );
mreq_opt.imr_multiaddr.s_addr = htonl(INADDR_MULTICAST_MDNS);
mreq_opt.imr_interface.s_addr = htonl(INADDR_ANY);
setsockopt(mDNS_fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq_opt, sizeof(ip_mreq));
addr.sin_family = AF_INET;
addr.sin_port = htons(5353);
addr.sin_addr.s_addr = INADDR_ANY;
err = bind(mDNS_fd, (struct sockaddr *)&addr, sizeof(addr));
require_noerr(err, exit);
err = mico_system_notify_register( mico_notify_WIFI_STATUS_CHANGED, (void *)BonjourNotify_WifiStatusHandler, NULL );
require_noerr( err, exit );
err = mico_system_notify_register( mico_notify_SYS_WILL_POWER_OFF, (void *)BonjourNotify_SYSWillPoerOffHandler, NULL );
require_noerr( err, exit );
err = mico_rtos_create_thread(&mfi_bonjour_thread_handler, MICO_APPLICATION_PRIORITY, "Bonjour", _bonjour_thread, 0x500, 0 );
require_noerr(err, exit);
bonjour_instance = true;
exit:
return err;
}
void _bonjour_thread(uint32_t arg)
{
int i, con = -1;
struct timeval t;
fd_set readfds;
struct sockaddr_in addr;
socklen_t addrLen;
//OSStatus err = kNoErr;
UNUSED_PARAMETER( arg );
t.tv_sec = 1;
t.tv_usec = 0;
while(1) {
/*Check status on erery sockets on bonjour query */
FD_ZERO(&readfds);
FD_SET(mDNS_fd, &readfds);
FD_SET(update_state_fd, &readfds);
select( Max( mDNS_fd, update_state_fd )+ 1, &readfds, NULL, NULL, &t );
if ( FD_ISSET( update_state_fd, &readfds ) ){
mdns_utils_log( "sem recved" );
mico_rtos_get_semaphore( &update_state_sem, 0 );
mico_rtos_lock_mutex( &bonjour_mutex );
for ( i = 0; i < available_service_count; i++ ){
switch ( available_services[i].state ){
case RECORD_REMOVE:
mdns_utils_log( "Remove record %d", i );
bonjour_send_record( i );
available_services[i].count_down--;
if( available_services[i].count_down == 0){
_clean_record_resource( &available_services[i] );
available_services[i].state = RECORD_REMOVED;
}
break;
case RECORD_SUSPEND:
if( available_services[i].count_down ){
mdns_utils_log( "Suspend record %d", i );
bonjour_send_record( i );
if( available_services[i].count_down )
available_services[i].count_down--;
}
break;
case RECORD_UPDATE:
mdns_utils_log( "Update record %d, cd: %d", i, available_services[i].count_down );
bonjour_send_record( i );
available_services[i].count_down--;
if( available_services[i].count_down == 0)
available_services[i].state = RECORD_NORMAL;
break;
default:
break;
}
}
mico_rtos_unlock_mutex( &bonjour_mutex );
}
/*Read data from udp and send data back */
if (FD_ISSET(mDNS_fd, &readfds)) {
con = recvfrom(mDNS_fd, buf, 1500, 0, (struct sockaddr *)&addr, &addrLen);
mico_rtos_lock_mutex( &bonjour_mutex );
mdns_handler(mDNS_fd, (uint8_t *)buf, con);
mico_rtos_unlock_mutex( &bonjour_mutex );
}
}
//mdns_utils_log("Exit: mDNS thread exit with err = %d", err);
//SocketClose( &mDNS_fd );
//if(buf) free(buf);
//mico_rtos_delete_thread(NULL);
}

130
mico-os/MiCO/system/mdns/mico_mdns.h Normal file
View File

@@ -0,0 +1,130 @@
/**
******************************************************************************
* @file mico_mdns.h
* @author William Xu
* @version V1.0.0
* @date 05-May-2014
* @brief This header contains function prototypes called by mdns protocol
* operations
******************************************************************************
* UNPUBLISHED PROPRIETARY SOURCE CODE
* Copyright (c) 2016 MXCHIP Inc.
*
* The contents of this file may not be disclosed to third parties, copied or
* duplicated in any form, in whole or in part, without the prior written
* permission of MXCHIP Corporation.
******************************************************************************
*/
#ifndef __MDNS_H
#define __MDNS_H
#include "mico.h"
/**************************************************************************************************************
* INCLUDES
**************************************************************************************************************/
#define MAX_RECORD_COUNT 4
#define DNS_MESSAGE_IS_A_RESPONSE 0x8000
#define DNS_MESSAGE_OPCODE 0x7800
#define DNS_MESSAGE_AUTHORITATIVE 0x0400
#define DNS_MESSAGE_TRUNCATION 0x0200
#define DNS_MESSAGE_RECURSION_DESIRED 0x0100
#define DNS_MESSAGE_RECURSION_AVAILABLE 0x0080
#define DNS_MESSAGE_RESPONSE_CODE 0x000F
typedef enum
{
DNS_NO_ERROR = 0,
DNS_FORMAT_ERROR = 1,
DNS_SERVER_FAILURE = 2,
DNS_NAME_ERROR = 3,
DNS_NOT_IMPLEMENTED = 4,
DNS_REFUSED = 5
} dns_message_response_code_t;
typedef enum
{
RR_TYPE_A = 1, // A - Host Address
RR_TYPE_NS = 2,
RR_TYPE_MD = 3,
RR_TYPE_MF = 4,
RR_TYPE_CNAME = 5,
RR_TYPE_SOA = 6,
RR_TYPE_MB = 7,
RR_TYPE_MG = 8,
RR_TYPE_MR = 9,
RR_TYPE_NULL = 10,
RR_TYPE_WKS = 11,
RR_TYPE_PTR = 12, // PTR - Domain Name pointer
RR_TYPE_HINFO = 13, // HINFO - Host Information
RR_TYPE_MINFO = 14,
RR_TYPE_MX = 15,
RR_TYPE_TXT = 16,
RR_TYPE_SRV = 33, // SRV - Service Location Record
RR_QTYPE_AXFR = 252,
RR_QTYPE_MAILB = 253,
RR_QTYPE_AILA = 254,
RR_QTYPE_ANY = 255
} dns_resource_record_type_t;
typedef enum
{
RR_CLASS_IN = 1,
RR_CLASS_CS = 2,
RR_CLASS_CH = 3,
RR_CLASS_HS = 4,
RR_CLASS_ALL = 255
} dns_resource_record_class_t;
#define RR_CACHE_FLUSH 0x8000
/**************************************************************************************************************
* STRUCTURES
**************************************************************************************************************/
typedef struct
{
uint8_t* start_of_name;
uint8_t* start_of_packet; // Used for compressed names;
} dns_name_t;
typedef struct
{
uint16_t id;
uint16_t flags;
uint16_t question_count;
uint16_t answer_count;
uint16_t name_server_count;
uint16_t additional_record_count;
} dns_message_header_t;
typedef struct
{
dns_message_header_t* header; // Also used as start of packet for compressed names
uint8_t* iter;
uint8_t* end;
} dns_message_iterator_t;
typedef struct
{
uint16_t question_type;
uint16_t question_class;
} dns_question_t;
typedef struct
{
uint16_t record_type;
uint16_t record_class;
uint32_t ttl;
uint16_t rd_length;
dns_message_iterator_t rdata;
} dns_record_t;
#endif

101
mico-os/MiCO/system/mdns/system_discovery.c Normal file
View File

@@ -0,0 +1,101 @@
/**
******************************************************************************
* @file MICOBonjour.c
* @author William Xu
* @version V1.0.0
* @date 05-May-2014
* @brief Zero-configuration protocol compatible with Bonjour from Apple
******************************************************************************
* UNPUBLISHED PROPRIETARY SOURCE CODE
* Copyright (c) 2016 MXCHIP Inc.
*
* The contents of this file may not be disclosed to third parties, copied or
* duplicated in any form, in whole or in part, without the prior written
* permission of MXCHIP Corporation.
******************************************************************************
*/
#include "mico.h"
#include "system_internal.h"
#include "platform_config.h"
#include "StringUtils.h"
OSStatus system_discovery_init( system_context_t * const inContext )
{
char *temp_txt= NULL;
char *temp_txt2;
OSStatus err;
net_para_st para;
mdns_init_t init;
temp_txt = malloc(500);
require_action(temp_txt, exit, err = kNoMemoryErr);
memset(&init, 0x0, sizeof(mdns_init_t));
micoWlanGetIPStatus(&para, Station);
init.service_name = "_easylink._tcp.local.";
/* name#xxxxxx.local. */
snprintf( temp_txt, 100, "%s#%c%c%c%c%c%c.local.", inContext->flashContentInRam.micoSystemConfig.name,
inContext->micoStatus.mac[9], inContext->micoStatus.mac[10], \
inContext->micoStatus.mac[12], inContext->micoStatus.mac[13], \
inContext->micoStatus.mac[15], inContext->micoStatus.mac[16] );
init.host_name = (char*)__strdup(temp_txt);
/* name#xxxxxx. */
snprintf( temp_txt, 100, "%s#%c%c%c%c%c%c", inContext->flashContentInRam.micoSystemConfig.name,
inContext->micoStatus.mac[9], inContext->micoStatus.mac[10], \
inContext->micoStatus.mac[12], inContext->micoStatus.mac[13], \
inContext->micoStatus.mac[15], inContext->micoStatus.mac[16] );
init.instance_name = (char*)__strdup(temp_txt);
#ifndef MICO_LOCAL_SERVER_PORT
init.service_port = MICO_CONFIG_SERVER_PORT;
#else
init.service_port = MICO_LOCAL_SERVER_PORT;
#endif
temp_txt2 = __strdup_trans_dot(inContext->micoStatus.mac);
sprintf(temp_txt, "MAC=%s.", temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(FIRMWARE_REVISION);
sprintf(temp_txt, "%sFirmware Rev=%s.", temp_txt, temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(HARDWARE_REVISION);
sprintf(temp_txt, "%sHardware Rev=%s.", temp_txt, temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(MicoGetVer());
sprintf(temp_txt, "%sMICO OS Rev=%s.", temp_txt, temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(MODEL);
sprintf(temp_txt, "%sModel=%s.", temp_txt, temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(PROTOCOL);
sprintf(temp_txt, "%sProtocol=%s.", temp_txt, temp_txt2);
free(temp_txt2);
temp_txt2 = __strdup_trans_dot(MANUFACTURER);
sprintf(temp_txt, "%sManufacturer=%s.", temp_txt, temp_txt2);
free(temp_txt2);
sprintf(temp_txt, "%sSeed=%lu.", temp_txt, inContext->flashContentInRam.micoSystemConfig.seed);
init.txt_record = (char*)__strdup(temp_txt);
mdns_add_record( init, Station, 1500);
free(init.host_name);
free(init.instance_name);
free(init.txt_record);
exit:
if(temp_txt) free(temp_txt);
return err;
}