bool SharedPortEndpoint::InitRemoteAddress() { // Why do we read SharedPortServer's address from a file rather // than getting it passed down to us via the environment or // having a (configurable) fixed port? Because the // SharedPortServer daemon may be listening via CCB, and its CCB // contact info may not be known as soon as it is started up // or may even change over time. // Why don't we just use a daemon client object to find the // address of the SharedPortServer daemon? Because daemon // client assumes we want the best address for _us_ to connect // to. That's not necessarily the public address that we want // to advertise for others to connect to. MyString shared_port_server_ad_file; if( !param(shared_port_server_ad_file,"SHARED_PORT_DAEMON_AD_FILE") ) { EXCEPT("SHARED_PORT_DAEMON_AD_FILE must be defined"); } FILE *fp = safe_fopen_wrapper_follow(shared_port_server_ad_file.Value(),"r"); if( !fp ) { dprintf(D_ALWAYS,"SharedPortEndpoint: failed to open %s: %s\n", shared_port_server_ad_file.Value(), strerror(errno)); return false; } int adIsEOF = 0, errorReadingAd = 0, adEmpty = 0; ClassAd *ad = new ClassAd(fp, "[classad-delimiter]", adIsEOF, errorReadingAd, adEmpty); ASSERT(ad); fclose( fp ); // avoid leaking ad when returning from this function counted_ptr<ClassAd> smart_ad_ptr(ad); if( errorReadingAd ) { dprintf(D_ALWAYS,"SharedPortEndpoint: failed to read ad from %s.\n", shared_port_server_ad_file.Value()); return false; } MyString public_addr; if( !ad->LookupString(ATTR_MY_ADDRESS,public_addr) ) { dprintf(D_ALWAYS, "SharedPortEndpoint: failed to find %s in ad from %s.\n", ATTR_MY_ADDRESS, shared_port_server_ad_file.Value()); return false; } Sinful sinful(public_addr.Value()); sinful.setSharedPortID( m_local_id.Value() ); // if there is a private address, set the shared port id on that too char const *private_addr = sinful.getPrivateAddr(); if( private_addr ) { Sinful private_sinful( private_addr ); private_sinful.setSharedPortID( m_local_id.Value() ); sinful.setPrivateAddr( private_sinful.getSinful() ); } // Next, look for alternate command strings std::string commandStrings; if (ad->EvaluateAttrString(ATTR_SHARED_PORT_COMMAND_SINFULS, commandStrings)) { m_remote_addrs.clear(); StringList sl(commandStrings.c_str()); sl.rewind(); const char *commandSinfulStr; while ((commandSinfulStr = sl.next())) { Sinful altsinful(commandSinfulStr); altsinful.setSharedPortID(m_local_id.Value()); char const *private_addr = sinful.getPrivateAddr(); if (private_addr) { Sinful private_sinful(private_addr); private_sinful.setSharedPortID(m_local_id.Value()); altsinful.setPrivateAddr(private_sinful.getSinful()); } m_remote_addrs.push_back(altsinful); } } m_remote_addr = sinful.getSinful(); return true; }
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(); }
UdpWakeOnLanWaker::UdpWakeOnLanWaker ( ClassAd *ad ) throw () : WakerBase () { int found = 0; /* make sure we are only capable of sending the WOL magic packet if all of the initialization succeds */ m_can_wake = false; /* retrieve the hardware address from the ad */ found = ad->LookupString ( ATTR_HARDWARE_ADDRESS, m_mac, STRING_MAC_ADDRESS_LENGTH ); if ( !found ) { dprintf ( D_ALWAYS, "UdpWakeOnLanWaker: no hardware address " "(MAC) defined\n" ); return; } /* retrieve the IP from the ad */ Daemon d(ad,DT_STARTD,NULL); char const *addr = d.addr(); Sinful sinful( addr ); if( !addr || !sinful.getHost() ) { dprintf ( D_ALWAYS, "UdpWakeOnLanWaker: no IP address defined\n" ); return; } strncpy( m_public_ip, sinful.getHost(), MAX_IP_ADDRESS_LENGTH-1); m_public_ip[MAX_IP_ADDRESS_LENGTH-1] = '\0'; /* retrieve the subnet from the ad */ found = ad->LookupString ( ATTR_SUBNET_MASK, m_subnet, MAX_IP_ADDRESS_LENGTH ); if ( !found ) { dprintf ( D_ALWAYS, "UdpWakeOnLanWaker: no subnet defined\n" ); return; } /* retrieve the port number from the ad */ found = ad->LookupInteger ( ATTR_WOL_PORT, m_port ); if ( !found ) { /* no error, just auto-detect the port number */ m_port = detect_port; } /* initialize the internal structures */ if ( !initialize () ) { dprintf ( D_ALWAYS, "UdpWakeOnLanWaker: failed to initialize\n" ); return; } /* if we made it here, then initialization succeeded */ m_can_wake = true; }