474 lines
12 KiB
C++
474 lines
12 KiB
C++
|
|
#include <avahi-client/client.h>
|
|
#include <avahi-client/publish.h>
|
|
|
|
#include <avahi-common/alternative.h>
|
|
#include <avahi-common/thread-watch.h>
|
|
#include <avahi-common/malloc.h>
|
|
#include <avahi-common/error.h>
|
|
#include <avahi-common/timeval.h>
|
|
#include <avahi-common/strlst.h>
|
|
|
|
|
|
#include "cwCommon.h"
|
|
#include "cwLog.h"
|
|
#include "cwCommonImpl.h"
|
|
#include "cwTime.h"
|
|
#include "cwThread.h"
|
|
#include "cwTcpSocket.h"
|
|
|
|
using namespace cw;
|
|
using namespace cw::net;
|
|
|
|
#define INSTANCE_NAME "MC Mix"
|
|
#define SERVICE_NAME "_EuConProxy._tcp"
|
|
#define SERVICE_PORT 49168
|
|
#define SERVICE_HOST nullptr //"Euphonix-MC-38C9863744E7.local"
|
|
#define ENET_INTERFACE "ens9"
|
|
#define SERVICE_TXT_0 "lmac=38-C9-86-37-44-E7"
|
|
#define SERVICE_TXT_1 "dummy=0"
|
|
#define HOST_MAC "hmac=00-E0-4C-A9-A4-8D" // mbp19 enet MAC
|
|
|
|
typedef struct app_str
|
|
{
|
|
AvahiEntryGroup *group = nullptr;
|
|
AvahiThreadedPoll *poll = nullptr;
|
|
char *name = nullptr;
|
|
unsigned instanceId = 0;
|
|
socket::handle_t tcpH;
|
|
thread::handle_t tcpThreadH;
|
|
unsigned recvBufByteN = 4096;
|
|
unsigned protocolState = 0;
|
|
unsigned txtXmtN = 0;
|
|
time::spec_t t0;
|
|
|
|
|
|
} app_t;
|
|
|
|
static void create_services(app_t* app, AvahiClient *c);
|
|
|
|
void errorv( app_t* app, const char* fmt, va_list vl )
|
|
{
|
|
vprintf(fmt,vl);
|
|
}
|
|
|
|
void logv( app_t* app, const char* fmt, va_list vl )
|
|
{
|
|
vprintf(fmt,vl);
|
|
}
|
|
|
|
void error( app_t* app, const char* fmt, ... )
|
|
{
|
|
va_list vl;
|
|
va_start(vl,fmt);
|
|
errorv( app, fmt, vl );
|
|
va_end(vl);
|
|
}
|
|
|
|
void rpt( app_t* app, const char* fmt, ... )
|
|
{
|
|
va_list vl;
|
|
va_start(vl,fmt);
|
|
logv( app, fmt, vl );
|
|
va_end(vl);
|
|
}
|
|
|
|
void choose_new_service_name( app_t* app )
|
|
{
|
|
char buf[255];
|
|
app->instanceId += 1;
|
|
snprintf(buf,sizeof(buf),"%s - %i", INSTANCE_NAME, app->instanceId);
|
|
|
|
char* n = avahi_strdup(buf);
|
|
avahi_free(app->name);
|
|
app->name = n;
|
|
|
|
rpt(app,"Service name collision, renaming service to '%s'\n", app->name);
|
|
}
|
|
|
|
static void entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata)
|
|
{
|
|
app_t* app = (app_t*)userdata;
|
|
|
|
assert(g == app->group || app->group == nullptr);
|
|
app->group = g;
|
|
|
|
// Called whenever the entry group state changes
|
|
|
|
switch (state)
|
|
{
|
|
case AVAHI_ENTRY_GROUP_ESTABLISHED :
|
|
// The entry group has been established successfully
|
|
rpt( app, "Service '%s' successfully established.\n", app->name);
|
|
break;
|
|
|
|
case AVAHI_ENTRY_GROUP_COLLISION :
|
|
{
|
|
|
|
// A service name collision with a remote service happened. Let's pick a new name.
|
|
choose_new_service_name(app);
|
|
|
|
// And recreate the services
|
|
create_services(app,avahi_entry_group_get_client(g));
|
|
break;
|
|
}
|
|
|
|
case AVAHI_ENTRY_GROUP_FAILURE :
|
|
|
|
error(app,"Entry group failure: %s\n", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))));
|
|
|
|
/* Some kind of failure happened while we were registering our services */
|
|
avahi_threaded_poll_quit(app->poll);
|
|
break;
|
|
|
|
case AVAHI_ENTRY_GROUP_UNCOMMITED:
|
|
case AVAHI_ENTRY_GROUP_REGISTERING:
|
|
;
|
|
}
|
|
}
|
|
|
|
static void create_services(app_t* app, AvahiClient *c)
|
|
{
|
|
int ret;
|
|
AvahiPublishFlags flags = (AvahiPublishFlags)0;
|
|
|
|
assert(c);
|
|
|
|
// If this is the first time we're called, create a new entry group
|
|
if (!app->group)
|
|
{
|
|
if (!(app->group = avahi_entry_group_new(c, entry_group_callback, app)))
|
|
{
|
|
error(app,"avahi_entry_group_new() failed: %s\n", avahi_strerror(avahi_client_errno(c)));
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
// If the group is empty (either because it was just created, or because it was reset previously, add our entries.
|
|
if (avahi_entry_group_is_empty(app->group))
|
|
{
|
|
rpt(app,"Adding service '%s'\n", app->name);
|
|
|
|
// Add the service to the group
|
|
if ((ret = avahi_entry_group_add_service(app->group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, flags, app->name, SERVICE_NAME, nullptr, SERVICE_HOST, SERVICE_PORT, SERVICE_TXT_0, SERVICE_TXT_1, nullptr)) < 0)
|
|
{
|
|
if (ret == AVAHI_ERR_COLLISION)
|
|
goto collision;
|
|
|
|
error(app, "Failed to add _ipp._tcp service: %s\n", avahi_strerror(ret));
|
|
goto fail;
|
|
}
|
|
|
|
// Tell the server to register the service
|
|
if ((ret = avahi_entry_group_commit(app->group)) < 0)
|
|
{
|
|
error(app,"Failed to commit entry group: %s\n", avahi_strerror(ret));
|
|
goto fail;
|
|
}
|
|
}
|
|
|
|
return;
|
|
|
|
collision:
|
|
|
|
// A service name collision with a local service happened. Pick a new name.
|
|
choose_new_service_name(app);
|
|
|
|
avahi_entry_group_reset(app->group);
|
|
|
|
create_services(app,c);
|
|
return;
|
|
|
|
fail:
|
|
avahi_threaded_poll_quit(app->poll);
|
|
}
|
|
|
|
|
|
static void client_callback(AvahiClient *c, AvahiClientState state, void * userdata)
|
|
{
|
|
assert(c);
|
|
|
|
app_t* app = (app_t*)userdata;
|
|
|
|
// Called whenever the client or server state changes
|
|
|
|
switch (state)
|
|
{
|
|
case AVAHI_CLIENT_S_RUNNING:
|
|
// The server has startup successfully and registered its host
|
|
// name on the network, so it's time to create our services
|
|
create_services(app,c);
|
|
break;
|
|
|
|
case AVAHI_CLIENT_FAILURE:
|
|
error(app,"Client failure: %s\n", avahi_strerror(avahi_client_errno(c)));
|
|
avahi_threaded_poll_quit(app->poll);
|
|
break;
|
|
|
|
case AVAHI_CLIENT_S_COLLISION:
|
|
// Let's drop our registered services. When the server is back
|
|
// in AVAHI_SERVER_RUNNING state we will register them
|
|
// again with the new host name.
|
|
rpt(app,"S Collision\n");
|
|
|
|
case AVAHI_CLIENT_S_REGISTERING:
|
|
|
|
rpt(app,"S Registering\n");
|
|
|
|
// The server records are now being established. This
|
|
// might be caused by a host name change. We need to wait
|
|
// for our own records to register until the host name is
|
|
// properly esatblished.
|
|
if (app->group)
|
|
avahi_entry_group_reset(app->group);
|
|
|
|
break;
|
|
|
|
case AVAHI_CLIENT_CONNECTING:
|
|
;
|
|
}
|
|
}
|
|
|
|
|
|
rc_t _send_response( app_t* app, const unsigned char* buf, unsigned bufByteN )
|
|
{
|
|
rc_t rc;
|
|
|
|
if((rc = socket::send( app->tcpH, buf, bufByteN )) != kOkRC )
|
|
{
|
|
error(app,"Send failed.");
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
rc_t send_response1( app_t* app )
|
|
{
|
|
// wifi: 98 5A EB 89 BA AA
|
|
// enet: 38 C9 86 37 44 E7
|
|
|
|
unsigned char buf[] =
|
|
{ 0x0b,0x00,0x00,0x00,0x00,0x00,0x00,0x50,0x00,0x02,0x03,0xfc,0x01,0x05,
|
|
0x06,0x00,
|
|
0x38,0xc9,0x86,0x37,0x44,0xe7,
|
|
0x01,0x00,
|
|
0xc0,0xa8,0x00,0x44,
|
|
0x00,0x00,
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
|
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
|
|
0x03,0xff,0x00,0x30,0x08,0x00,0x00,0x80,0x00,0x40,0x01,0x01,0x00,0x00,0x00,0x00,
|
|
0x00,0x00
|
|
};
|
|
|
|
return _send_response(app,buf,sizeof(buf));
|
|
}
|
|
|
|
rc_t send_response2( app_t* app )
|
|
{
|
|
unsigned char buf[] = { 0x0d,0x00,0x00,0x00,0x00,0x00,0x00,0x08 };
|
|
|
|
return _send_response(app,buf,sizeof(buf));
|
|
}
|
|
|
|
rc_t send_heart_beat( app_t* app )
|
|
{
|
|
unsigned char buf[] = { 0x03,0x00,0x00,0x00 };
|
|
return _send_response(app,buf,sizeof(buf));
|
|
}
|
|
|
|
rc_t send_txt( app_t* app, bool updateFl=true )
|
|
{
|
|
rc_t rc = kOkRC;
|
|
int ret;
|
|
|
|
const char* array[] =
|
|
{
|
|
"lmac=38-C9-86-37-44-E7",
|
|
"host=mbp19",
|
|
"hmac=BE-BD-EA-31-F9-88",
|
|
"dummy=1"
|
|
};
|
|
|
|
AvahiStringList* list = avahi_string_list_new_from_array(array,4);
|
|
if( updateFl )
|
|
ret = avahi_entry_group_update_service_txt_strlst(app->group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags)0, app->name, SERVICE_NAME, nullptr, list);
|
|
else
|
|
ret = avahi_entry_group_add_service_strlst(app->group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags)0, app->name, SERVICE_NAME, nullptr, nullptr, SERVICE_PORT, list);
|
|
|
|
if(ret < 0)
|
|
{
|
|
error(app,"Failed to %s entry group text: %s\n", updateFl ? "update" : "add", avahi_strerror(ret));
|
|
goto fail;
|
|
}
|
|
|
|
avahi_string_list_free(list);
|
|
|
|
fail:
|
|
|
|
return rc;
|
|
}
|
|
|
|
bool tcpReceiveCallback( void* arg )
|
|
{
|
|
app_t* app = static_cast<app_t*>(arg);
|
|
socket::handle_t sockH = app->tcpH;
|
|
char buf[ app->recvBufByteN ];
|
|
unsigned readByteN = 0;
|
|
rc_t rc = kOkRC;
|
|
time::spec_t t1;
|
|
|
|
if( !socket::isConnected(sockH) )
|
|
{
|
|
if((rc = socket::accept( sockH )) == kOkRC )
|
|
{
|
|
rpt(app,"TCP connected.\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((rc = socket::receive( sockH, buf, app->recvBufByteN, &readByteN, nullptr )) == kOkRC || rc == kTimeOutRC )
|
|
{
|
|
if( rc == kTimeOutRC )
|
|
{
|
|
|
|
}
|
|
else
|
|
if( readByteN > 0 )
|
|
{
|
|
unsigned* h = (unsigned*)buf;
|
|
unsigned id = h[0];
|
|
switch( app->protocolState )
|
|
{
|
|
case 0:
|
|
if( id == 10 )
|
|
{
|
|
send_response1(app);
|
|
sleepMs(20);
|
|
send_heart_beat(app);
|
|
app->protocolState+=1;
|
|
}
|
|
break;
|
|
|
|
case 1:
|
|
{
|
|
if( buf[0] == 0x0c )
|
|
{
|
|
send_response2(app);
|
|
app->protocolState+=1;
|
|
time::get(app->t0);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case 2:
|
|
{
|
|
time::get(t1);
|
|
if( time::elapsedMs( &app->t0, &t1 ) >= 4000 )
|
|
{
|
|
send_heart_beat(app);
|
|
app->t0 = t1;
|
|
}
|
|
}
|
|
break;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
int main( int argc, const char* argv[] )
|
|
{
|
|
|
|
AvahiClient *client = nullptr;
|
|
int err_code;
|
|
int ret = 1;
|
|
const unsigned sbufN = 31;
|
|
char sbuf[ sbufN+1 ];
|
|
app_t app;
|
|
rc_t rc;
|
|
unsigned tcpTimeOutMs = 50;
|
|
|
|
cw::log::createGlobal();
|
|
|
|
// create the TCP socket
|
|
if((rc = socket::create(
|
|
app.tcpH,
|
|
SERVICE_PORT,
|
|
socket::kTcpFl | socket::kBlockingFl | socket::kStreamFl | socket::kListenFl,
|
|
tcpTimeOutMs,
|
|
NULL,
|
|
socket::kInvalidPortNumber )) != kOkRC )
|
|
{
|
|
rc = cwLogError(rc,"mDNS TCP socket create failed.");
|
|
goto errLabel;
|
|
}
|
|
|
|
unsigned char mac[6];
|
|
socket::get_mac( app.tcpH, mac, nullptr, ENET_INTERFACE );
|
|
for(int i=0; i<6; ++i)
|
|
printf("%02x:",mac[i]);
|
|
|
|
|
|
// create the TCP listening thread
|
|
if((rc = thread::create( app.tcpThreadH, tcpReceiveCallback, &app, "avahi_suf" )) != kOkRC )
|
|
goto errLabel;
|
|
|
|
// Allocate Avahi thread
|
|
if (!(app.poll = avahi_threaded_poll_new()))
|
|
{
|
|
error(&app,"Failed to create simple poll object.\n");
|
|
goto errLabel;
|
|
}
|
|
|
|
// Assign the service name
|
|
app.name = avahi_strdup(INSTANCE_NAME);
|
|
|
|
// Allocate a new client
|
|
if((client = avahi_client_new(avahi_threaded_poll_get(app.poll), (AvahiClientFlags)0, client_callback, &app, &err_code)) == nullptr )
|
|
{
|
|
error(&app,"Failed to create client: %s\n", avahi_strerror(err_code));
|
|
goto errLabel;
|
|
}
|
|
|
|
// start the tcp thread
|
|
if((rc = thread::unpause( app.tcpThreadH )) != kOkRC )
|
|
goto errLabel;
|
|
|
|
// start the avahi thread
|
|
avahi_threaded_poll_start(app.poll);
|
|
|
|
while( true )
|
|
{
|
|
printf("? ");
|
|
if( std::fgets(sbuf,sbufN,stdin) == sbuf )
|
|
{
|
|
if( strcmp(sbuf,"quit\n") == 0)
|
|
break;
|
|
}
|
|
}
|
|
|
|
avahi_threaded_poll_stop(app.poll);
|
|
|
|
ret = 0;
|
|
|
|
errLabel:
|
|
|
|
//if (client)
|
|
// avahi_client_free(client);
|
|
|
|
thread::destroy(app.tcpThreadH);
|
|
socket::destroy(app.tcpH);
|
|
|
|
if (app.poll)
|
|
avahi_threaded_poll_free(app.poll);
|
|
|
|
avahi_free(app.name);
|
|
|
|
|
|
cw::log::destroyGlobal();
|
|
|
|
return ret;
|
|
}
|