int NSCLASS dsr_ack_opt_recv(struct dsr_ack_opt *ack)
{
unsigned short id;
struct in_addr dst, src, myaddr;
int n;
if (!ack)
return DSR_PKT_ERROR;
myaddr = my_addr();
dst.s_addr = ack->dst;
src.s_addr = ack->src;
id = ntohs(ack->id);
LOG_DBG("ACK dst=%s src=%s id=%u\n", print_ip(dst), print_ip(src), id);
if (dst.s_addr != myaddr.s_addr)
return DSR_PKT_ERROR;
/* Purge packets buffered for this next hop */
n = maint_buf_del_all_id(src, id);
LOG_DBG("Removed %d packets from maint buf\n", n);
return DSR_PKT_NONE;
}
int TestNrSocket::write(const void *msg, size_t len, size_t *written) {
UCHAR *buf = static_cast<UCHAR*>(const_cast<void*>(msg));
if (nat_->block_stun_ && nr_is_stun_message(buf, len)) {
// Should cause this socket to be abandoned
r_log(LOG_GENERIC, LOG_DEBUG,
"TestNrSocket %s dropping outgoing TCP "
"because it is configured to drop STUN",
my_addr().as_string);
return R_INTERNAL;
}
if (nat_->block_tcp_ && !tls_) {
// Should cause this socket to be abandoned
r_log(LOG_GENERIC, LOG_DEBUG,
"TestNrSocket %s dropping outgoing TCP "
"because it is configured to drop TCP",
my_addr().as_string);
return R_INTERNAL;
}
if (port_mappings_.empty()) {
// The no-nat case, just pass call through.
r_log(LOG_GENERIC, LOG_DEBUG, "TestNrSocket %s writing",
my_addr().as_string);
return internal_socket_->write(msg, len, written);
}
destroy_stale_port_mappings();
if (port_mappings_.empty()) {
r_log(LOG_GENERIC, LOG_DEBUG,
"TestNrSocket %s dropping outgoing TCP "
"because the port mapping was stale",
my_addr().as_string);
return R_INTERNAL;
}
// This is TCP only
MOZ_ASSERT(port_mappings_.size() == 1);
r_log(LOG_GENERIC, LOG_DEBUG,
"PortMapping %s -> %s writing",
port_mappings_.front()->external_socket_->my_addr().as_string,
port_mappings_.front()->remote_address_.as_string);
port_mappings_.front()->last_used_ = PR_IntervalNow();
return port_mappings_.front()->external_socket_->write(msg, len, written);
}
void
CCBListeners::Configure(char const *addresses)
{
StringList addrlist(addresses," ,");
CCBListenerList new_ccbs;
char const *address;
addrlist.rewind();
while( (address=addrlist.next()) ) {
CCBListener *listener;
// preserve existing CCBListener if there is one connected
// to this address
listener = GetCCBListener( address );
if( !listener ) {
Daemon daemon(DT_COLLECTOR,address);
char const *ccb_addr_str = daemon.addr();
char const *my_addr_str = daemonCore->publicNetworkIpAddr();
Sinful ccb_addr( ccb_addr_str );
Sinful my_addr( my_addr_str );
if( my_addr.addressPointsToMe( ccb_addr ) ) {
dprintf(D_ALWAYS,"CCBListener: skipping CCB Server %s because it points to myself.\n",address);
continue;
}
dprintf(D_FULLDEBUG,"CCBListener: good: CCB address %s does not point to my address %s\n",
ccb_addr_str?ccb_addr_str:"null",
my_addr_str?my_addr_str:"null");
listener = new CCBListener(address);
}
new_ccbs.push_back( listener );
}
m_ccb_listeners.clear();
classy_counted_ptr<CCBListener> ccb_listener;
for(CCBListenerList::iterator itr = new_ccbs.begin();
itr != new_ccbs.end();
itr++)
{
ccb_listener = (*itr);
if( GetCCBListener( ccb_listener->getAddress() ) ) {
// ignore duplicate entries with same address
continue;
}
m_ccb_listeners.push_back( ccb_listener );
ccb_listener->InitAndReconfig();
}
}
int NSCLASS dsr_ack_req_send(struct in_addr neigh_addr, unsigned short id)
{
struct dsr_pkt *dp;
struct dsr_ack_req_opt *ack_req;
int len = DSR_OPT_HDR_LEN + DSR_ACK_REQ_HDR_LEN;
char *buf;
dp = dsr_pkt_alloc(NULL);
dp->dst = neigh_addr;
dp->nxt_hop = neigh_addr;
dp->src = my_addr();
buf = dsr_pkt_alloc_opts(dp, len);
if (!buf)
goto out_err;
dp->nh.iph = dsr_build_ip(dp, dp->src, dp->dst, IP_HDR_LEN,
IP_HDR_LEN + len, IPPROTO_DSR, 1);
if (!dp->nh.iph) {
LOG_DBG("Could not create IP header\n");
goto out_err;
}
dp->dh.opth = dsr_opt_hdr_add(buf, len, DSR_NO_NEXT_HDR_TYPE);
if (!dp->dh.opth) {
LOG_DBG("Could not create DSR opt header\n");
goto out_err;
}
buf += DSR_OPT_HDR_LEN;
len -= DSR_OPT_HDR_LEN;
ack_req = dsr_ack_req_opt_create(buf, len, id);
if (!ack_req) {
LOG_DBG("Could not create ACK REQ opt\n");
goto out_err;
}
LOG_DBG("Sending ACK REQ for %s id=%u\n", print_ip(neigh_addr), id);
XMIT(dp);
return 1;
out_err:
dsr_pkt_free(dp);
return -1;
}
// Listing 2 code/ch09
void echo_dgram (void)
{
ACE_INET_Addr my_addr (ACE_static_cast (u_short, 10102));
ACE_INET_Addr your_addr;
ACE_SOCK_Dgram udp (my_addr);
char buff[BUFSIZ];
size_t buflen = sizeof (buff);
ssize_t recv_cnt = udp.recv (buff, buflen, your_addr);
if (recv_cnt > 0)
udp.send (buff, ACE_static_cast (size_t, buflen), your_addr);
udp.close ();
return;
}
int send_unicast (const ACE_INET_Addr &to)
{
const char *message = "this is the message!\n";
ACE_INET_Addr my_addr (ACE_static_cast (u_short, 10101));
ACE_SOCK_Dgram udp (my_addr);
ssize_t sent = udp.send (message,
ACE_OS_String::strlen (message) + 1,
to);
udp.close ();
if (sent == -1)
ACE_ERROR_RETURN ((LM_ERROR, ACE_TEXT ("%p\n"),
ACE_TEXT ("send")), -1);
return 0;
}
// passing over REPLICATION_LIST configuration parameter, turning all the
// addresses into canonical <ip:port> form and inserting them all, except for
// the address of local replication daemon, into 'm_replicationDaemonsList'.
void
AbstractReplicatorStateMachine::initializeReplicationList( char* buffer )
{
StringList replicationAddressList;
char* replicationAddress = NULL;
bool isMyAddressPresent = false;
Sinful my_addr( daemonCore->InfoCommandSinfulString( ) );
replicationAddressList.initializeFromString( buffer );
// initializing a list unrolls it, that's why the rewind is needed to bring
// it to the beginning
replicationAddressList.rewind( );
/* Passing through the REPLICATION_LIST configuration parameter, stripping
* the optional <> brackets off, and extracting the host name out of
* either ip:port or hostName:port entries
*/
while( (replicationAddress = replicationAddressList.next( )) ) {
char* sinfulAddress = utilToSinful( replicationAddress );
if( sinfulAddress == NULL ) {
char bufArray[BUFSIZ];
sprintf( bufArray,
"AbstractReplicatorStateMachine::initializeReplicationList"
" invalid address %s\n", replicationAddress );
utilCrucialError( bufArray );
continue;
}
if( my_addr.addressPointsToMe( Sinful(sinfulAddress) ) ) {
isMyAddressPresent = true;
}
else {
m_replicationDaemonsList.insert( sinfulAddress );
}
// pay attention to release memory allocated by malloc with free and by
// new with delete here utilToSinful returns memory allocated by malloc
free( sinfulAddress );
}
if( !isMyAddressPresent ) {
utilCrucialError( "ReplicatorStateMachine::initializeReplicationList "
"my address is not present in REPLICATION_LIST" );
}
}
int TestNrSocket::write(const void *msg, size_t len, size_t *written) {
ASSERT_ON_THREAD(ststhread_);
if (port_mappings_.empty()) {
// The no-nat case, just pass call through.
r_log(LOG_GENERIC, LOG_INFO, "TestNrSocket %s writing",
my_addr().as_string);
return NrSocket::write(msg, len, written);
} else {
// This is TCP only
MOZ_ASSERT(port_mappings_.size() == 1);
r_log(LOG_GENERIC, LOG_INFO,
"PortMapping %s -> %s writing",
port_mappings_.front()->external_socket_->my_addr().as_string,
port_mappings_.front()->remote_address_.as_string);
return port_mappings_.front()->external_socket_->write(msg, len, written);
}
}
int main(int argc, char **argv)
{
char *Address = NULL;
char *btaddr = NULL;
int Port = 9777;
int NumSamples = WIIREMOTE_SAMPLES;
float DeadX = DEADZONE_X;
float DeadY = DEADZONE_Y;
char *JoyMap = NULL;
for (int i = 0; i < argc; i++)
{
if (strcmp(argv[i], "--help") == 0)
{
PrintHelp(argv[0]);
return 0;
}
else if (strcmp(argv[i], "--disable-mouseemulation") == 0)
g_AllowMouse = false;
else if (strcmp(argv[i], "--disable-reconnect") == 0)
g_AllowReconnect = false;
else if (strcmp(argv[i], "--disable-nunchuck") == 0)
g_AllowNunchuck = false;
else if (strcmp(argv[i], "--address") == 0 && ((i + 1) <= argc))
Address = argv[i + 1];
else if (strcmp(argv[i], "--port") == 0 && ((i + 1) <= argc))
Port = atoi(argv[i + 1]);
else if (strcmp(argv[i], "--btaddr") == 0 && ((i + 1) <= argc))
btaddr = argv[i + 1];
else if (strcmp(argv[i], "--deadzone-x") == 0 && ((i + 1) <= argc))
DeadX = ((float)atoi(argv[i + 1]) / 100.0f);
else if (strcmp(argv[i], "--deadzone-y") == 0 && ((i + 1) <= argc))
DeadY = ((float)atoi(argv[i + 1]) / 100.0f);
else if (strcmp(argv[i], "--deadzone") == 0 && ((i + 1) <= argc))
DeadX = DeadY = ((float)atoi(argv[i + 1]) / 100.0f);
else if (strcmp(argv[i], "--smoothing-samples") == 0 && ((i + 1) <= argc))
NumSamples = atoi(argv[i + 1]);
else if (strcmp(argv[i], "--joystick-map") == 0 && ((i + 1) <= argc))
JoyMap = argv[i + 1];
}
if (NumSamples < 1 || DeadX < 0 || DeadY < 0 || DeadX > 1 || DeadY > 1)
{
PrintHelp(argv[0]);
return -1;
}
CAddress my_addr(Address, Port); // Address => localhost on 9777
int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
if (sockfd < 0)
{
printf("Error creating socket\n");
return -1;
}
if (hci_get_route(NULL) < 0)
{
CPacketLOG log(LOGERROR, "Error No bluetooth device");
log.Send(sockfd, my_addr);
return -1;
}
g_Ping = new CPacketHELO("WiiRemote", ICON_PNG, g_BluetoothIconPath.c_str());
g_WiiRemote.Initialize(my_addr, sockfd);
g_WiiRemote.SetBluetoothAddress(btaddr);
g_WiiRemote.SetSensativity(DeadX, DeadY, NumSamples);
g_WiiRemote.SetSensativity(DeadX, DeadY, NumSamples);
g_WiiRemote.SetJoystickMap(JoyMap);
if (g_AllowMouse)
g_WiiRemote.EnableMouseEmulation();
else
g_WiiRemote.DisableMouseEmulation();
g_Ping->Send(sockfd, my_addr);
bool HaveConnected = false;
while (true)
{
bool Connected = g_WiiRemote.GetConnected();
while (!Connected)
{
if (HaveConnected && !g_AllowReconnect)
exit(0);
Connected = g_WiiRemote.Connect();
HaveConnected = true;
}
#ifdef CWIID_OLD
// Update the state of the WiiRemote more often when we have the old lib due too it not telling when disconnected..
sleep (5);
#else
sleep (15);
#endif
g_Ping->Send(sockfd, my_addr);
g_WiiRemote.Update();
}
}
int NSCLASS dsr_ack_send(struct in_addr dst, unsigned short id)
{
struct dsr_pkt *dp;
struct dsr_ack_opt *ack_opt;
int len;
char *buf;
/* srt = dsr_rtc_find(my_addr(), dst); */
/* if (!srt) { */
/* LOG_DBG("No source route to %s\n", print_ip(dst.s_addr)); */
/* return -1; */
/* } */
len = DSR_OPT_HDR_LEN + /* DSR_SRT_OPT_LEN(srt) + */ DSR_ACK_HDR_LEN;
dp = dsr_pkt_alloc(NULL);
dp->dst = dst;
/* dp->srt = srt; */
dp->nxt_hop = dst; //dsr_srt_next_hop(dp->srt, 0);
dp->src = my_addr();
buf = dsr_pkt_alloc_opts(dp, len);
if (!buf)
goto out_err;
dp->nh.iph = dsr_build_ip(dp, dp->src, dp->dst, IP_HDR_LEN,
IP_HDR_LEN + len, IPPROTO_DSR, IPDEFTTL);
if (!dp->nh.iph) {
LOG_DBG("Could not create IP header\n");
goto out_err;
}
dp->dh.opth = dsr_opt_hdr_add(buf, len, DSR_NO_NEXT_HDR_TYPE);
if (!dp->dh.opth) {
LOG_DBG("Could not create DSR opt header\n");
goto out_err;
}
buf += DSR_OPT_HDR_LEN;
len -= DSR_OPT_HDR_LEN;
/* dp->srt_opt = dsr_srt_opt_add(buf, len, dp->srt); */
/* if (!dp->srt_opt) { */
/* LOG_DBG("Could not create Source Route option header\n"); */
/* goto out_err; */
/* } */
/* buf += DSR_SRT_OPT_LEN(dp->srt); */
/* len -= DSR_SRT_OPT_LEN(dp->srt); */
ack_opt = dsr_ack_opt_add(buf, len, dp->src, dp->dst, id);
if (!ack_opt) {
LOG_DBG("Could not create DSR ACK opt header\n");
goto out_err;
}
LOG_DBG("Sending ACK to %s id=%u\n", print_ip(dst), id);
dp->flags |= PKT_XMIT_JITTER;
XMIT(dp);
return 1;
out_err:
dsr_pkt_free(dp);
return -1;
}
void
CCBServer::InitAndReconfig()
{
// construct the CCB address to be advertised by CCB listeners
Sinful sinful(daemonCore->publicNetworkIpAddr());
// strip out <>'s, private address, and CCB listener info
sinful.setPrivateAddr(NULL);
sinful.setCCBContact(NULL);
ASSERT( sinful.getSinful() && sinful.getSinful()[0] == '<' );
m_address.formatstr("%s",sinful.getSinful()+1);
if( m_address[m_address.Length()-1] == '>' ) {
m_address.setChar(m_address.Length()-1,'\0');
}
m_read_buffer_size = param_integer("CCB_SERVER_READ_BUFFER",2*1024);
m_write_buffer_size = param_integer("CCB_SERVER_WRITE_BUFFER",2*1024);
m_last_reconnect_info_sweep = time(NULL);
m_reconnect_info_sweep_interval = param_integer("CCB_SWEEP_INTERVAL",1200);
CloseReconnectFile();
MyString old_reconnect_fname = m_reconnect_fname;
char *fname = param("CCB_RECONNECT_FILE");
if( fname ) {
m_reconnect_fname = fname;
if( m_reconnect_fname.find(".ccb_reconnect") == -1 ) {
// required for preen to ignore this file
m_reconnect_fname += ".ccb_reconnect";
}
free( fname );
}
else {
char *spool = param("SPOOL");
ASSERT( spool );
Sinful my_addr( daemonCore->publicNetworkIpAddr() );
m_reconnect_fname.formatstr("%s%c%s-%s.ccb_reconnect",
spool,
DIR_DELIM_CHAR,
my_addr.getHost() ? my_addr.getHost() : "localhost",
my_addr.getPort() ? my_addr.getPort() : "0");
free( spool );
}
if( old_reconnect_fname != m_reconnect_fname &&
!old_reconnect_fname.IsEmpty() &&
!m_reconnect_fname.IsEmpty() )
{
// reconnect filename changed
// not worth freaking out on error here
remove( m_reconnect_fname.Value() );
rename( old_reconnect_fname.Value(), m_reconnect_fname.Value() );
}
if( old_reconnect_fname.IsEmpty() &&
!m_reconnect_fname.IsEmpty() &&
m_reconnect_info.getNumElements() == 0 )
{
// we are starting up from scratch, so load saved info
LoadReconnectInfo();
}
Timeslice poll_slice;
poll_slice.setTimeslice( // do not run more than this fraction of the time
param_double("CCB_POLLING_TIMESLICE",0.05) );
poll_slice.setDefaultInterval( // try to run this often
param_integer("CCB_POLLING_INTERVAL",20,0) );
poll_slice.setMaxInterval( // run at least this often
param_integer("CCB_POLLING_MAX_INTERVAL",600) );
if( m_polling_timer != -1 ) {
daemonCore->Cancel_Timer(m_polling_timer);
}
m_polling_timer = daemonCore->Register_Timer(
poll_slice,
(TimerHandlercpp)&CCBServer::PollSockets,
"CCBServer::PollSockets",
this);
RegisterHandlers();
}
bool CNotificationKodi::SendMessageImplementation(
const uint64_t Idx,
const std::string &Name,
const std::string &Subject,
const std::string &Text,
const std::string &ExtraData,
const int Priority,
const std::string &Sound,
const bool bFromNotification)
{
std::string sSubject("Domoticz");
if (Subject != Text)
{
sSubject = Subject;
}
else
{
size_t posDevice = ExtraData.find("|Name=");
if (posDevice != std::string::npos)
{
posDevice+=6;
sSubject = ExtraData.substr(posDevice, ExtraData.find("|", posDevice)-posDevice);
}
}
std::string sIconFile = GetIconFile(ExtraData);
// Loop through semi-colon separated IP Addresses
std::vector<std::string> results;
StringSplit(_IPAddress, ";", results);
for (int i=0; i < (int)results.size(); i++)
{
std::stringstream logline;
logline << "Kodi Notification (" << results[i] << ":" << _Port << ", TTL " << _TTL << "): " << sSubject << ", " << Text << ", Icon " << sIconFile;
_log.Log(LOG_NORM, "%s", logline.str().c_str());
CAddress _Address;
int _Sock;
bool bMulticast = (results[i].substr(0,4) >= "224.") && (results[i].substr(0,4) <= "239.");
CAddress my_addr(results[i].c_str(), _Port);
_Address = my_addr;
_Sock = -1;
if (bMulticast) {
_Sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
setsockopt(_Sock, IPPROTO_IP, IP_MULTICAST_TTL, (const char*)&_TTL, sizeof(_TTL));
u_char loop = 1;
setsockopt(_Sock, IPPROTO_IP, IP_MULTICAST_LOOP, (const char*) &loop, sizeof(loop));
}
else {
_Sock = socket(AF_INET, SOCK_DGRAM, 0);
}
if (_Sock < 0)
{
logline << "Error creating socket: " << results[i] << ":" << _Port;
_log.Log(LOG_ERROR, "%s", logline.str().c_str());
return false;
}
_Address.Bind(_Sock);
CPacketNOTIFICATION packet(sSubject.c_str(), Text.c_str(), ICON_PNG, (!sIconFile.empty())?sIconFile.c_str():NULL);
if (!packet.Send(_Sock, _Address)) {
std::stringstream logline;
logline << "Error sending notification: " << results[i] << ":" << _Port;
_log.Log(LOG_ERROR, "%s", logline.str().c_str());
return false;
}
}
return true;
}
int NSCLASS dsr_opt_recv(struct dsr_pkt *dp)
{
int dsr_len, l;
int action = 0;
struct dsr_opt *dopt;
struct in_addr myaddr;
if (!dp)
return DSR_PKT_ERROR;
myaddr = my_addr();
/* Packet for us ? */
if (dp->dst.s_addr == myaddr.s_addr && dp->payload_len != 0)
action |= DSR_PKT_DELIVER;
dsr_len = dsr_pkt_opts_len(dp);
l = DSR_OPT_HDR_LEN;
dopt = DSR_GET_OPT(dp->dh.opth);
//DEBUG("Parsing DSR packet l=%d dsr_len=%d\n", l, dsr_len);
while (l < dsr_len && (dsr_len - l) > 2) {
//DEBUG("dsr_len=%d l=%d\n", dsr_len, l);
switch (dopt->type) {
case DSR_OPT_PADN:
break;
case DSR_OPT_RREQ:
if (dp->flags & PKT_PROMISC_RECV)
break;
action |= dsr_rreq_opt_recv(dp, (struct dsr_rreq_opt *)dopt);
break;
case DSR_OPT_RREP:
/* We should probably allow promisuously
* receiving RREPs */
if (dp->flags & PKT_PROMISC_RECV)
break;
action |= dsr_rrep_opt_recv(dp, (struct dsr_rrep_opt *)dopt);
break;
case DSR_OPT_RERR:
if (dp->flags & PKT_PROMISC_RECV)
break;
if (dp->num_rerr_opts < MAX_RERR_OPTS) {
action |=
dsr_rerr_opt_recv(dp, (struct dsr_rerr_opt *)dopt);
}
break;
case DSR_OPT_PREV_HOP:
break;
case DSR_OPT_ACK:
if (dp->flags & PKT_PROMISC_RECV)
break;
if (dp->num_ack_opts < MAX_ACK_OPTS) {
dp->ack_opt[dp->num_ack_opts++] =
(struct dsr_ack_opt *)dopt;
action |=
dsr_ack_opt_recv((struct dsr_ack_opt *)
dopt);
}
break;
case DSR_OPT_SRT:
action |= dsr_srt_opt_recv(dp, (struct dsr_srt_opt *)dopt);
break;
case DSR_OPT_TIMEOUT:
break;
case DSR_OPT_FLOWID:
break;
case DSR_OPT_ACK_REQ:
action |=
dsr_ack_req_opt_recv(dp, (struct dsr_ack_req_opt *)
dopt);
break;
case DSR_OPT_PAD1:
l++;
dopt++;
continue;
default:
DEBUG("Unknown DSR option type=%d\n", dopt->type);
}
l += dopt->length + 2;
dopt = DSR_GET_NEXT_OPT(dopt);
}
return action;
}
