zephyr
/
esp-idf
mirror of https://github.com/zephyrproject-rtos/esp-idf.git
1
0
Fork 0
Code Issues Releases Wiki Activity
esp-idf/components/mdns/mdns_console.c

1061 lines
32 KiB
C
Raw Permalink Blame History

// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <stdio.h>
#include <string.h>
#include "esp_console.h"
#include "argtable3/argtable3.h"
#include "mdns.h"
static const char * if_str[] = {"STA", "AP", "ETH", "MAX"};
static const char * ip_protocol_str[] = {"V4", "V6", "MAX"};
static void mdns_print_results(mdns_result_t * results)
{
mdns_result_t * r = results;
mdns_ip_addr_t * a = NULL;
int i = 1, t;
while (r) {
printf("%d: Interface: %s, Type: %s\n", i++, if_str[r->tcpip_if], ip_protocol_str[r->ip_protocol]);
if (r->instance_name) {
printf(" PTR : %s\n", r->instance_name);
}
if (r->hostname) {
printf(" SRV : %s.local:%u\n", r->hostname, r->port);
}
if (r->txt_count) {
printf(" TXT : [%u] ", r->txt_count);
for (t=0; t<r->txt_count; t++) {
printf("%s=%s; ", r->txt[t].key, r->txt[t].value);
}
printf("\n");
}
a = r->addr;
while (a) {
if (a->addr.type == IPADDR_TYPE_V6) {
printf(" AAAA: " IPV6STR "\n", IPV62STR(a->addr.u_addr.ip6));
} else {
printf(" A : " IPSTR "\n", IP2STR(&(a->addr.u_addr.ip4)));
}
a = a->next;
}
r = r->next;
}
}
static struct {
struct arg_str *hostname;
struct arg_int *timeout;
struct arg_end *end;
} mdns_query_a_args;
static int cmd_mdns_query_a(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_a_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_a_args.end, argv[0]);
return 1;
}
const char * hostname = mdns_query_a_args.hostname->sval[0];
int timeout = mdns_query_a_args.timeout->ival[0];
if (!hostname || !hostname[0]) {
printf("ERROR: Hostname not supplied\n");
return 1;
}
if (timeout <= 0) {
timeout = 1000;
}
printf("Query A: %s.local, Timeout: %d\n", hostname, timeout);
struct ip4_addr addr;
addr.addr = 0;
esp_err_t err = mdns_query_a(hostname, timeout, &addr);
if (err) {
if (err == ESP_ERR_NOT_FOUND) {
printf("ERROR: Host was not found!\n");
return 0;
}
printf("ERROR: Query Failed\n");
return 1;
}
printf(IPSTR "\n", IP2STR(&addr));
return 0;
}
static void register_mdns_query_a()
{
mdns_query_a_args.hostname = arg_str1(NULL, NULL, "<hostname>", "Hostname that is searched for");
mdns_query_a_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_a_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_a",
.help = "Query MDNS for IPv4",
.hint = NULL,
.func = &cmd_mdns_query_a,
.argtable = &mdns_query_a_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static int cmd_mdns_query_aaaa(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_a_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_a_args.end, argv[0]);
return 1;
}
const char * hostname = mdns_query_a_args.hostname->sval[0];
int timeout = mdns_query_a_args.timeout->ival[0];
if (!hostname || !hostname[0]) {
printf("ERROR: Hostname not supplied\n");
return 1;
}
if (timeout <= 0) {
timeout = 1000;
}
printf("Query AAAA: %s.local, Timeout: %d\n", hostname, timeout);
struct ip6_addr addr;
memset(addr.addr, 0, 16);
esp_err_t err = mdns_query_aaaa(hostname, timeout, &addr);
if (err) {
if (err == ESP_ERR_NOT_FOUND) {
printf("Host was not found!\n");
return 0;
}
printf("ERROR: Query Failed\n");
return 1;
}
printf(IPV6STR "\n", IPV62STR(addr));
return 0;
}
static void register_mdns_query_aaaa()
{
mdns_query_a_args.hostname = arg_str1(NULL, NULL, "<hostname>", "Hostname that is searched for");
mdns_query_a_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_a_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_aaaa",
.help = "Query MDNS for IPv6",
.hint = NULL,
.func = &cmd_mdns_query_aaaa,
.argtable = &mdns_query_a_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *instance;
struct arg_str *service;
struct arg_str *proto;
struct arg_int *timeout;
struct arg_end *end;
} mdns_query_srv_args;
static int cmd_mdns_query_srv(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_srv_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_srv_args.end, argv[0]);
return 1;
}
const char * instance = mdns_query_srv_args.instance->sval[0];
const char * service = mdns_query_srv_args.service->sval[0];
const char * proto = mdns_query_srv_args.proto->sval[0];
int timeout = mdns_query_srv_args.timeout->ival[0];
if (timeout <= 0) {
timeout = 1000;
}
printf("Query SRV: %s.%s.%s.local, Timeout: %d\n", instance, service, proto, timeout);
mdns_result_t * results = NULL;
esp_err_t err = mdns_query_srv(instance, service, proto, timeout, &results);
if (err) {
printf("ERROR: Query Failed\n");
return 1;
}
if (!results) {
printf("No results found!\n");
return 0;
}
mdns_print_results(results);
mdns_query_results_free(results);
return 0;
}
static void register_mdns_query_srv()
{
mdns_query_srv_args.instance = arg_str1(NULL, NULL, "<instance>", "Instance to search for");
mdns_query_srv_args.service = arg_str1(NULL, NULL, "<service>", "Service to search for (ex. _http, _smb, etc.)");
mdns_query_srv_args.proto = arg_str1(NULL, NULL, "<proto>", "Protocol to search for (_tcp, _udp, etc.)");
mdns_query_srv_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_srv_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_srv",
.help = "Query MDNS for Service SRV",
.hint = NULL,
.func = &cmd_mdns_query_srv,
.argtable = &mdns_query_srv_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *instance;
struct arg_str *service;
struct arg_str *proto;
struct arg_int *timeout;
struct arg_end *end;
} mdns_query_txt_args;
static int cmd_mdns_query_txt(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_txt_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_txt_args.end, argv[0]);
return 1;
}
const char * instance = mdns_query_txt_args.instance->sval[0];
const char * service = mdns_query_txt_args.service->sval[0];
const char * proto = mdns_query_txt_args.proto->sval[0];
int timeout = mdns_query_txt_args.timeout->ival[0];
printf("Query TXT: %s.%s.%s.local, Timeout: %d\n", instance, service, proto, timeout);
if (timeout <= 0) {
timeout = 5000;
}
mdns_result_t * results = NULL;
esp_err_t err = mdns_query_txt(instance, service, proto, timeout, &results);
if (err) {
printf("ERROR: Query Failed\n");
return 1;
}
if (!results) {
printf("No results found!\n");
return 0;
}
mdns_print_results(results);
mdns_query_results_free(results);
return 0;
}
static void register_mdns_query_txt()
{
mdns_query_txt_args.instance = arg_str1(NULL, NULL, "<instance>", "Instance to search for");
mdns_query_txt_args.service = arg_str1(NULL, NULL, "<service>", "Service to search for (ex. _http, _smb, etc.)");
mdns_query_txt_args.proto = arg_str1(NULL, NULL, "<proto>", "Protocol to search for (_tcp, _udp, etc.)");
mdns_query_txt_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_txt_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_txt",
.help = "Query MDNS for Service TXT",
.hint = NULL,
.func = &cmd_mdns_query_txt,
.argtable = &mdns_query_txt_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_int *timeout;
struct arg_int *max_results;
struct arg_end *end;
} mdns_query_ptr_args;
static int cmd_mdns_query_ptr(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_ptr_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_ptr_args.end, argv[0]);
return 1;
}
const char * service = mdns_query_ptr_args.service->sval[0];
const char * proto = mdns_query_ptr_args.proto->sval[0];
int timeout = mdns_query_ptr_args.timeout->ival[0];
int max_results = mdns_query_ptr_args.max_results->ival[0];
if (timeout <= 0) {
timeout = 5000;
}
if (max_results <= 0 || max_results > 255) {
max_results = 255;
}
printf("Query PTR: %s.%s.local, Timeout: %d, Max Results: %d\n", service, proto, timeout, max_results);
mdns_result_t * results = NULL;
esp_err_t err = mdns_query_ptr(service, proto, timeout, max_results, &results);
if (err) {
printf("ERROR: Query Failed\n");
return 1;
}
if (!results) {
printf("No results found!\n");
return 0;
}
mdns_print_results(results);
mdns_query_results_free(results);
return 0;
}
static void register_mdns_query_ptr()
{
mdns_query_ptr_args.service = arg_str1(NULL, NULL, "<service>", "Service to search for (ex. _http, _smb, etc.)");
mdns_query_ptr_args.proto = arg_str1(NULL, NULL, "<proto>", "Protocol to search for (_tcp, _udp, etc.)");
mdns_query_ptr_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_ptr_args.max_results = arg_int0("m", "max_results", "<max_results>", "Maximum results returned");
mdns_query_ptr_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_ptr",
.help = "Query MDNS for Service",
.hint = NULL,
.func = &cmd_mdns_query_ptr,
.argtable = &mdns_query_ptr_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *hostname;
struct arg_int *timeout;
struct arg_int *max_results;
struct arg_end *end;
} mdns_query_ip_args;
static int cmd_mdns_query_ip(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_ip_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_ip_args.end, argv[0]);
return 1;
}
const char * hostname = mdns_query_ip_args.hostname->sval[0];
int timeout = mdns_query_ip_args.timeout->ival[0];
int max_results = mdns_query_ip_args.max_results->ival[0];
if (!hostname || !hostname[0]) {
printf("ERROR: Hostname not supplied\n");
return 1;
}
if (timeout <= 0) {
timeout = 1000;
}
if (max_results < 0 || max_results > 255) {
max_results = 255;
}
printf("Query IP: %s.local, Timeout: %d, Max Results: %d\n", hostname, timeout, max_results);
mdns_result_t * results = NULL;
esp_err_t err = mdns_query(hostname, NULL, NULL, MDNS_TYPE_ANY, timeout, max_results, &results);
if (err) {
printf("ERROR: Query Failed\n");
return 1;
}
if (!results) {
printf("No results found!\n");
return 0;
}
mdns_print_results(results);
mdns_query_results_free(results);
return 0;
}
static void register_mdns_query_ip()
{
mdns_query_ip_args.hostname = arg_str1(NULL, NULL, "<hostname>", "Hostname that is searched for");
mdns_query_ip_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_ip_args.max_results = arg_int0("m", "max_results", "<max_results>", "Maximum results returned");
mdns_query_ip_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_ip",
.help = "Query MDNS for IP",
.hint = NULL,
.func = &cmd_mdns_query_ip,
.argtable = &mdns_query_ip_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *instance;
struct arg_str *service;
struct arg_str *proto;
struct arg_int *timeout;
struct arg_int *max_results;
struct arg_end *end;
} mdns_query_svc_args;
static int cmd_mdns_query_svc(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_query_svc_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_query_svc_args.end, argv[0]);
return 1;
}
const char * instance = mdns_query_svc_args.instance->sval[0];
const char * service = mdns_query_svc_args.service->sval[0];
const char * proto = mdns_query_svc_args.proto->sval[0];
int timeout = mdns_query_svc_args.timeout->ival[0];
int max_results = mdns_query_svc_args.max_results->ival[0];
if (timeout <= 0) {
timeout = 5000;
}
if (max_results < 0 || max_results > 255) {
max_results = 255;
}
printf("Query SVC: %s.%s.%s.local, Timeout: %d, Max Results: %d\n", instance, service, proto, timeout, max_results);
mdns_result_t * results = NULL;
esp_err_t err = mdns_query(instance, service, proto, MDNS_TYPE_ANY, timeout, max_results, &results);
if (err) {
printf("ERROR: Query Failed\n");
return 1;
}
if (!results) {
printf("No results found!\n");
return 0;
}
mdns_print_results(results);
mdns_query_results_free(results);
return 0;
}
static void register_mdns_query_svc()
{
mdns_query_svc_args.instance = arg_str1(NULL, NULL, "<instance>", "Instance to search for");
mdns_query_svc_args.service = arg_str1(NULL, NULL, "<service>", "Service to search for (ex. _http, _smb, etc.)");
mdns_query_svc_args.proto = arg_str1(NULL, NULL, "<proto>", "Protocol to search for (_tcp, _udp, etc.)");
mdns_query_svc_args.timeout = arg_int0("t", "timeout", "<timeout>", "Timeout for this query");
mdns_query_svc_args.max_results = arg_int0("m", "max_results", "<max_results>", "Maximum results returned");
mdns_query_svc_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_query_svc",
.help = "Query MDNS for Service TXT & SRV",
.hint = NULL,
.func = &cmd_mdns_query_svc,
.argtable = &mdns_query_svc_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static struct {
struct arg_str *hostname;
struct arg_str *instance;
struct arg_end *end;
} mdns_init_args;
static int cmd_mdns_init(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_init_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_init_args.end, argv[0]);
return 1;
}
ESP_ERROR_CHECK( mdns_init() );
if (mdns_init_args.hostname->sval[0]) {
ESP_ERROR_CHECK( mdns_hostname_set(mdns_init_args.hostname->sval[0]) );
printf("MDNS: Hostname: %s\n", mdns_init_args.hostname->sval[0]);
}
if (mdns_init_args.instance->sval[0]) {
ESP_ERROR_CHECK( mdns_instance_name_set(mdns_init_args.instance->sval[0]) );
printf("MDNS: Instance: %s\n", mdns_init_args.instance->sval[0]);
}
return 0;
}
static void register_mdns_init()
{
mdns_init_args.hostname = arg_str0("h", "hostname", "<hostname>", "Hostname that the server will advertise");
mdns_init_args.instance = arg_str0("i", "instance", "<instance>", "Default instance name for services");
mdns_init_args.end = arg_end(2);
const esp_console_cmd_t cmd_init = {
.command = "mdns_init",
.help = "Start MDNS Server",
.hint = NULL,
.func = &cmd_mdns_init,
.argtable = &mdns_init_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_init) );
}
static int cmd_mdns_free(int argc, char** argv)
{
mdns_free();
return 0;
}
static void register_mdns_free()
{
const esp_console_cmd_t cmd_free = {
.command = "mdns_free",
.help = "Stop MDNS Server",
.hint = NULL,
.func = &cmd_mdns_free,
.argtable = NULL
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_free) );
}
static struct {
struct arg_str *hostname;
struct arg_end *end;
} mdns_set_hostname_args;
static int cmd_mdns_set_hostname(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_set_hostname_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_set_hostname_args.end, argv[0]);
return 1;
}
if (mdns_set_hostname_args.hostname->sval[0] == NULL) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_hostname_set(mdns_set_hostname_args.hostname->sval[0]) );
return 0;
}
static void register_mdns_set_hostname()
{
mdns_set_hostname_args.hostname = arg_str1(NULL, NULL, "<hostname>", "Hostname that the server will advertise");
mdns_set_hostname_args.end = arg_end(2);
const esp_console_cmd_t cmd_set_hostname = {
.command = "mdns_set_hostname",
.help = "Set MDNS Server hostname",
.hint = NULL,
.func = &cmd_mdns_set_hostname,
.argtable = &mdns_set_hostname_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_set_hostname) );
}
static struct {
struct arg_str *instance;
struct arg_end *end;
} mdns_set_instance_args;
static int cmd_mdns_set_instance(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_set_instance_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_set_instance_args.end, argv[0]);
return 1;
}
if (mdns_set_instance_args.instance->sval[0] == NULL) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_instance_name_set(mdns_set_instance_args.instance->sval[0]) );
return 0;
}
static void register_mdns_set_instance()
{
mdns_set_instance_args.instance = arg_str1(NULL, NULL, "<instance>", "Default instance name for services");
mdns_set_instance_args.end = arg_end(2);
const esp_console_cmd_t cmd_set_instance = {
.command = "mdns_set_instance",
.help = "Set MDNS Server Istance Name",
.hint = NULL,
.func = &cmd_mdns_set_instance,
.argtable = &mdns_set_instance_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_set_instance) );
}
static mdns_txt_item_t * _convert_items(const char **values, int count)
{
int i=0,e;
const char * value = NULL;
mdns_txt_item_t * items = (mdns_txt_item_t*) malloc(sizeof(mdns_txt_item_t) * count);
if (!items) {
printf("ERROR: No Memory!\n");
goto fail;
}
memset(items, 0, sizeof(mdns_txt_item_t) * count);
for (i=0; i<count; i++) {
value = values[i];
char * esign = strchr(value, '=');
if (!esign) {
printf("ERROR: Equal sign not found in '%s'!\n", value);
goto fail;
}
int var_len = esign - value;
int val_len = strlen(value) - var_len - 1;
char * var = (char*)malloc(var_len+1);
if (var == NULL) {
printf("ERROR: No Memory!\n");
goto fail;
}
char * val = (char*)malloc(val_len+1);
if (val == NULL) {
printf("ERROR: No Memory!\n");
free(var);
goto fail;
}
memcpy(var, value, var_len);
var[var_len] = 0;
memcpy(val, esign+1, val_len);
val[val_len] = 0;
items[i].key = var;
items[i].value = val;
}
return items;
fail:
for (e=0;e<i;e++) {
free((char *)items[e].key);
free((char *)items[e].value);
}
free(items);
return NULL;
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_int *port;
struct arg_str *instance;
struct arg_str *txt;
struct arg_end *end;
} mdns_add_args;
static int cmd_mdns_service_add(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_add_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_add_args.end, argv[0]);
return 1;
}
if (!mdns_add_args.service->sval[0] || !mdns_add_args.proto->sval[0] || !mdns_add_args.port->ival[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
const char * instance = NULL;
if (mdns_add_args.instance->sval[0] && mdns_add_args.instance->sval[0][0]) {
instance = mdns_add_args.instance->sval[0];
printf("MDNS: Service Instance: %s\n", instance);
}
mdns_txt_item_t * items = NULL;
if (mdns_add_args.txt->count) {
items = _convert_items(mdns_add_args.txt->sval, mdns_add_args.txt->count);
if (!items) {
printf("ERROR: No Memory!\n");
return 1;
}
}
ESP_ERROR_CHECK( mdns_service_add(instance, mdns_add_args.service->sval[0], mdns_add_args.proto->sval[0], mdns_add_args.port->ival[0], items, mdns_add_args.txt->count) );
free(items);
return 0;
}
static void register_mdns_service_add()
{
mdns_add_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_add_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_add_args.port = arg_int1(NULL, NULL, "<port>", "Service Port");
mdns_add_args.instance = arg_str0("i", "instance", "<instance>", "Instance name");
mdns_add_args.txt = arg_strn(NULL, NULL, "item", 0, 30, "TXT Items (name=value)");
mdns_add_args.end = arg_end(2);
const esp_console_cmd_t cmd_add = {
.command = "mdns_service_add",
.help = "Add service to MDNS",
.hint = NULL,
.func = &cmd_mdns_service_add,
.argtable = &mdns_add_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_end *end;
} mdns_remove_args;
static int cmd_mdns_service_remove(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_remove_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_remove_args.end, argv[0]);
return 1;
}
if (!mdns_remove_args.service->sval[0] || !mdns_remove_args.proto->sval[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_service_remove(mdns_remove_args.service->sval[0], mdns_remove_args.proto->sval[0]) );
return 0;
}
static void register_mdns_service_remove()
{
mdns_remove_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_remove_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_remove_args.end = arg_end(2);
const esp_console_cmd_t cmd_remove = {
.command = "mdns_service_remove",
.help = "Remove service from MDNS",
.hint = NULL,
.func = &cmd_mdns_service_remove,
.argtable = &mdns_remove_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_remove) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_str *instance;
struct arg_end *end;
} mdns_service_instance_set_args;
static int cmd_mdns_service_instance_set(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_service_instance_set_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_service_instance_set_args.end, argv[0]);
return 1;
}
if (!mdns_service_instance_set_args.service->sval[0] || !mdns_service_instance_set_args.proto->sval[0] || !mdns_service_instance_set_args.instance->sval[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_service_instance_name_set(mdns_service_instance_set_args.service->sval[0], mdns_service_instance_set_args.proto->sval[0], mdns_service_instance_set_args.instance->sval[0]) );
return 0;
}
static void register_mdns_service_instance_set()
{
mdns_service_instance_set_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_service_instance_set_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_service_instance_set_args.instance = arg_str1(NULL, NULL, "<instance>", "Instance name");
mdns_service_instance_set_args.end = arg_end(2);
const esp_console_cmd_t cmd_add = {
.command = "mdns_service_instance_set",
.help = "Set MDNS Service Instance Name",
.hint = NULL,
.func = &cmd_mdns_service_instance_set,
.argtable = &mdns_service_instance_set_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_int *port;
struct arg_end *end;
} mdns_service_port_set_args;
static int cmd_mdns_service_port_set(int argc, char** argv) {
int nerrors = arg_parse(argc, argv, (void**) &mdns_service_port_set_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_service_port_set_args.end, argv[0]);
return 1;
}
if (!mdns_service_port_set_args.service->sval[0] || !mdns_service_port_set_args.proto->sval[0] || !mdns_service_port_set_args.port->ival[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_service_port_set(mdns_service_port_set_args.service->sval[0], mdns_service_port_set_args.proto->sval[0], mdns_service_port_set_args.port->ival[0]) );
return 0;
}
static void register_mdns_service_port_set()
{
mdns_service_port_set_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_service_port_set_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_service_port_set_args.port = arg_int1(NULL, NULL, "<port>", "Service Port");
mdns_service_port_set_args.end = arg_end(2);
const esp_console_cmd_t cmd_add = {
.command = "mdns_service_port_set",
.help = "Set MDNS Service port",
.hint = NULL,
.func = &cmd_mdns_service_port_set,
.argtable = &mdns_service_port_set_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_add) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_str *txt;
struct arg_end *end;
} mdns_txt_replace_args;
static int cmd_mdns_service_txt_replace(int argc, char** argv)
{
mdns_txt_item_t * items = NULL;
int nerrors = arg_parse(argc, argv, (void**) &mdns_txt_replace_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_txt_replace_args.end, argv[0]);
return 1;
}
if (!mdns_txt_replace_args.service->sval[0] || !mdns_txt_replace_args.proto->sval[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
if (mdns_txt_replace_args.txt->count) {
items = _convert_items(mdns_txt_replace_args.txt->sval, mdns_txt_replace_args.txt->count);
if (!items) {
printf("ERROR: No Memory!\n");
return 1;
}
}
ESP_ERROR_CHECK( mdns_service_txt_set(mdns_txt_replace_args.service->sval[0], mdns_txt_replace_args.proto->sval[0], items, mdns_txt_replace_args.txt->count) );
free(items);
return 0;
}
static void register_mdns_service_txt_replace()
{
mdns_txt_replace_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_txt_replace_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_txt_replace_args.txt = arg_strn(NULL, NULL, "item", 0, 30, "TXT Items (name=value)");
mdns_txt_replace_args.end = arg_end(2);
const esp_console_cmd_t cmd_txt_set = {
.command = "mdns_service_txt_replace",
.help = "Replace MDNS service TXT items",
.hint = NULL,
.func = &cmd_mdns_service_txt_replace,
.argtable = &mdns_txt_replace_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_set) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_str *var;
struct arg_str *value;
struct arg_end *end;
} mdns_txt_set_args;
static int cmd_mdns_service_txt_set(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_txt_set_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_txt_set_args.end, argv[0]);
return 1;
}
if (!mdns_txt_set_args.service->sval[0] || !mdns_txt_set_args.proto->sval[0] || !mdns_txt_set_args.var->sval[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_service_txt_item_set(mdns_txt_set_args.service->sval[0], mdns_txt_set_args.proto->sval[0], mdns_txt_set_args.var->sval[0], mdns_txt_set_args.value->sval[0]) );
return 0;
}
static void register_mdns_service_txt_set()
{
mdns_txt_set_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_txt_set_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_txt_set_args.var = arg_str1(NULL, NULL, "<var>", "Item Name");
mdns_txt_set_args.value = arg_str1(NULL, NULL, "<value>", "Item Value");
mdns_txt_set_args.end = arg_end(2);
const esp_console_cmd_t cmd_txt_set = {
.command = "mdns_service_txt_set",
.help = "Add/Set MDNS service TXT item",
.hint = NULL,
.func = &cmd_mdns_service_txt_set,
.argtable = &mdns_txt_set_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_set) );
}
static struct {
struct arg_str *service;
struct arg_str *proto;
struct arg_str *var;
struct arg_end *end;
} mdns_txt_remove_args;
static int cmd_mdns_service_txt_remove(int argc, char** argv)
{
int nerrors = arg_parse(argc, argv, (void**) &mdns_txt_remove_args);
if (nerrors != 0) {
arg_print_errors(stderr, mdns_txt_remove_args.end, argv[0]);
return 1;
}
if (!mdns_txt_remove_args.service->sval[0] || !mdns_txt_remove_args.proto->sval[0] || !mdns_txt_remove_args.var->sval[0]) {
printf("ERROR: Bad arguments!\n");
return 1;
}
ESP_ERROR_CHECK( mdns_service_txt_item_remove(mdns_txt_remove_args.service->sval[0], mdns_txt_remove_args.proto->sval[0], mdns_txt_remove_args.var->sval[0]) );
return 0;
}
static void register_mdns_service_txt_remove()
{
mdns_txt_remove_args.service = arg_str1(NULL, NULL, "<service>", "MDNS Service");
mdns_txt_remove_args.proto = arg_str1(NULL, NULL, "<proto>", "IP Protocol");
mdns_txt_remove_args.var = arg_str1(NULL, NULL, "<var>", "Item Name");
mdns_txt_remove_args.end = arg_end(2);
const esp_console_cmd_t cmd_txt_remove = {
.command = "mdns_service_txt_remove",
.help = "Remove MDNS service TXT item",
.hint = NULL,
.func = &cmd_mdns_service_txt_remove,
.argtable = &mdns_txt_remove_args
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_txt_remove) );
}
static int cmd_mdns_service_remove_all(int argc, char** argv)
{
mdns_service_remove_all();
return 0;
}
static void register_mdns_service_remove_all()
{
const esp_console_cmd_t cmd_free = {
.command = "mdns_service_remove_all",
.help = "Remove all MDNS services",
.hint = NULL,
.func = &cmd_mdns_service_remove_all,
.argtable = NULL
};
ESP_ERROR_CHECK( esp_console_cmd_register(&cmd_free) );
}
void mdns_console_register()
{
register_mdns_init();
register_mdns_free();
register_mdns_set_hostname();
register_mdns_set_instance();
register_mdns_service_add();
register_mdns_service_remove();
register_mdns_service_instance_set();
register_mdns_service_port_set();
register_mdns_service_txt_replace();
register_mdns_service_txt_set();
register_mdns_service_txt_remove();
register_mdns_service_remove_all();
register_mdns_query_a();
register_mdns_query_aaaa();
register_mdns_query_txt();
register_mdns_query_srv();
register_mdns_query_ptr();
register_mdns_query_ip();
register_mdns_query_svc();
}
Reference in New Issue View Git Blame Copy Permalink