int main (int argc, char * argv []) { // apply default settings QucsSettings.x = 200; QucsSettings.y = 100; QucsSettings.font = QFont("Helvetica", 12); // is application relocated? char * var = getenv ("QUCSDIR"); QDir QucsDir; if (var != NULL) { QucsDir = QDir (var); QString QucsDirStr = QucsDir.canonicalPath (); QucsSettings.LangDir = QDir::convertSeparators (QucsDirStr + "/share/qucs/lang/"); } else { QString QucsApplicationPath = QCoreApplication::applicationDirPath(); #ifdef __APPLE__ QucsDir = QDir(QucsApplicationPath.section("/bin",0,0)); #else QucsDir = QDir(QucsApplicationPath); QucsDir.cdUp(); #endif QucsSettings.LangDir = QucsDir.canonicalPath() + "/share/qucs/lang/"; } loadSettings(); QApplication app (argc, argv); qf_spec* spec_p; int result = 0; app.setFont( QucsSettings.font ); QTranslator tor( 0 ); QString lang = QucsSettings.Language; if(lang.isEmpty()) lang = QTextCodec::locale(); tor.load( QString("qucs_") + lang, QucsSettings.LangDir); app.installTranslator( &tor ); qf_box Filterbox; Filterbox.setFont (QucsSettings.font); Filterbox.move (QucsSettings.x, QucsSettings.y); Filterbox.show (); Filterbox.FilterName->setCurrentItem (QucsSettings.type); Filterbox.on_FilterName_activated (QucsSettings.form); Filterbox.TformName->setCurrentItem (QucsSettings.form); Filterbox.on_TformName_activated (QucsSettings.type); Filterbox.EnterCutoff->setText (QString::number (QucsSettings.cutoff)); Filterbox.CutoffCombo->setCurrentItem (QucsSettings.cutoff_unit); Filterbox.EnterZin->setText (QString::number (QucsSettings.zin)); Filterbox.EnterZout->setText (QString::number (QucsSettings.zout)); Filterbox.OrderBox->setChecked (QucsSettings.specify); Filterbox.OrderCombo->setCurrentItem (QucsSettings.ord); Filterbox.SubOrderCombo->setCurrentItem (QucsSettings.subord); Filterbox.EnterBandwidth->setText (QString::number (QucsSettings.bw)); Filterbox.BandwidthCombo->setCurrentItem (QucsSettings.bw_unit); Filterbox.EnterStopband->setText (QString::number (QucsSettings.sb)); Filterbox.StopbandCombo->setCurrentItem (QucsSettings.sb_unit); Filterbox.EnterRipple->setText (QString::number (QucsSettings.ripple)); Filterbox.EnterAngle->setText (QString::number (QucsSettings.angle)); Filterbox.EnterAttenuation->setText (QString::number (QucsSettings.atten)); while (true) { if (Filterbox. exec () != QDialog::Accepted) break; spec_p = Filterbox. get_spec (); QByteArray buf; Q3TextStream s (buf, QIODevice::ReadWrite); compute_lumped (spec_p, s); // FIXME #warning s. device () -> flush (); QClipboard *cb = QApplication::clipboard(); cb->setText(buf); } saveSettings (&Filterbox); saveXmlSettings (&Filterbox); return result; }
int main(void) { BYTE flgRestart = FALSE; // if TRUE, restart main loop struct ifreq interface; // ioctls to configure network interface struct sockaddr_in myinterface; // Interface address struct sockaddr_in mynetmask; // Interface netmask struct sockaddr_in mybroadcast; // Interface broadcast address int server_sockfd; // Server socket struct sockaddr_in server_address; // Server address and port int heartbeat_sockfd; // Heartbeat socket struct sockaddr_in heartbeat_addr; // Heartbeat address and port int tx_sockfd; // Tx socket int optval, optlen; // Vars for socket options time_t timenow; // Current time time_t xaptick; // Last tick time_t heartbeattick; // Time for next hearbeat tick char heartbeat_msg[1500]; // Buffer for heartbeat messages char buff[1500]; // Buffer for messages fd_set rdfs; // Vars for attent to clients struct timeval tv; struct sockaddr_in client_address; // client address and port socklen_t client_len; int i; // Auxiliary variable // Header verbage //printf("\nHomected xAP-Hub Connector\n"); //printf("Copyright (C) Jose Luis Galindo, 2012\n"); // Create shared memory areas if (!hubSharedMemSetup()) { syslog(LOG_ERR, "main: Error allocating shared resources"); logError("main: Error allocating shared resources"); } // Initialize application init(); logInit(LOG_EVENTS_FILE, LOG_ERRORS_FILE); LIBXML_TEST_VERSION // Create the process process_init("xap-hub", pid_filepath); while(process_state == PROC_RUNNING) { // Load xml file with general settings if (parseXmlSettings(SETTINGS_FILE) > 0) { syslog(LOG_ERR, "main: Failed to parse xml settings document, default values loaded"); logError("main: Failed to parse xml settings document, default values loaded"); if (saveXmlSettings(SETTINGS_FILE) > 0) { syslog(LOG_ERR, "main: Error saving settings file"); logError("main: Error saving settings file"); } } // Use the server socket to get interface properties server_sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (server_sockfd == -1) { syslog(LOG_ERR, "main: Error trying to get interface properties"); logError("main: Error trying to get interface properties"); unlink(pid_filepath); exit(EXIT_FAILURE); } // Set options for the socket optval=1; optlen=sizeof(int); if (setsockopt(server_sockfd, SOL_SOCKET, SO_BROADCAST, (char*)&optval, optlen)) { syslog(LOG_ERR, "main: Error trying to get interface properties"); logError("main: Error trying to get interface properties"); unlink(pid_filepath); exit(EXIT_FAILURE); } optval=1; optlen=sizeof(int); if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, (char*)&optval, optlen)) { syslog(LOG_ERR, "main: Error trying to get interface properties"); logError("main: Error trying to get interface properties"); unlink(pid_filepath); exit(EXIT_FAILURE); } // Query the low-level capabilities of the network interface to get address and netmask memset((char*)&interface, sizeof(interface),0); strcpy(interface.ifr_name, hubConfig->interfacename); // Get the interface address interface.ifr_addr.sa_family = AF_INET; if (ioctl(server_sockfd, SIOCGIFADDR, &interface) != 0) { syslog(LOG_ERR, "main: Could not determine IP address for interface %s", hubConfig->interfacename); logError("main: Could not determine IP address for interface %s", hubConfig->interfacename); unlink(pid_filepath); exit(EXIT_FAILURE); } myinterface.sin_addr.s_addr = ((struct sockaddr_in*)&interface.ifr_broadaddr)->sin_addr.s_addr; //printf("%s: address %s\n", interface.ifr_name, inet_ntoa(((struct sockaddr_in*)&interface.ifr_addr)->sin_addr)); logEvent(TRUE, "main: %s: address %s", interface.ifr_name, inet_ntoa(((struct sockaddr_in*)&interface.ifr_addr)->sin_addr)); // Get the interface netmask interface.ifr_broadaddr.sa_family = AF_INET; if (ioctl(server_sockfd, SIOCGIFNETMASK, &interface) != 0) { syslog(LOG_ERR, "Unable to determine netmask for interface %s", hubConfig->interfacename); logError("main: Unable to determine netmask for interface %s", hubConfig->interfacename); unlink(pid_filepath); exit(EXIT_FAILURE); } mynetmask.sin_addr.s_addr = ((struct sockaddr_in*)&interface.ifr_broadaddr)->sin_addr.s_addr; //printf("%s: netmask %s\n", interface.ifr_name, inet_ntoa(((struct sockaddr_in*)&interface.ifr_netmask)->sin_addr)); logEvent(TRUE, "main: %s: netmask %s", interface.ifr_name, inet_ntoa(((struct sockaddr_in*)&interface.ifr_netmask)->sin_addr)); // Determine the interface broadcast address long int inverted_netmask; inverted_netmask=~mynetmask.sin_addr.s_addr; mybroadcast.sin_addr.s_addr = inverted_netmask | myinterface.sin_addr.s_addr; //printf("%s: broadcast %s\n", interface.ifr_name, inet_ntoa(mybroadcast.sin_addr)); logEvent(TRUE, "main: %s: broadcast %s", interface.ifr_name, inet_ntoa(mybroadcast.sin_addr)); // Set the server socket server_sockfd = socket(AF_INET, SOCK_DGRAM, 0); // Set server address and port memset((char *) &server_address, 0, sizeof(server_address)); server_address.sin_family = AF_INET; server_address.sin_addr.s_addr = htonl(INADDR_ANY); // Receive from any address server_address.sin_port = htons(hubConfig->xap_port); // on this port (Default 3639) // Bind the server socket with the server IP address and port fcntl(server_sockfd, F_SETFL, O_NONBLOCK); if (bind(server_sockfd, (struct sockaddr*)&server_address, sizeof(server_address)) !=0 ) { // if fails then we can assume that a hub is active on this host syslog(LOG_ERR, "main: Port %d is in use", hubConfig->xap_port); syslog(LOG_ERR, "main: Assuming other local hub is active on this host"); logError("main: Port %d is in use", hubConfig->xap_port); logError("main: Assuming other local hub is active on this host"); unlink(pid_filepath); exit(EXIT_FAILURE); } //printf("Listening for messages on port %d\n", g_xap_port); logEvent(TRUE, "main: Listening for messages on port %d", hubConfig->xap_port); // Set the server socket to listen listen(server_sockfd, MAX_QUEUE_BACKLOG); // Set up the Tx socket tx_sockfd = socket(AF_INET, SOCK_DGRAM, 0); // Set up the heartbeat socket, on which we tell the world we are alive and well heartbeat_sockfd = socket(AF_INET, SOCK_DGRAM, 0); if (heartbeat_sockfd == -1) { syslog(LOG_ERR, "main: Heartbeat socket cannot be created"); logError("main: Heartbeat socket cannot be created"); unlink(pid_filepath); exit(EXIT_FAILURE); } // Set options for the heartbeat socket optval = 1; optlen = sizeof(int); if (setsockopt(heartbeat_sockfd, SOL_SOCKET, SO_BROADCAST, (char*)&optval, optlen)) { syslog(LOG_ERR, "main: Unable to set heartbeat socket options"); logError("main: Unable to set heartbeat socket options"); unlink(pid_filepath); exit(EXIT_FAILURE); } // Set up heartbeat address and port memset((char *) &heartbeat_addr, 0, sizeof(heartbeat_addr)); heartbeat_addr.sin_family = AF_INET; heartbeat_addr.sin_port = htons(hubConfig->xap_port); heartbeat_addr.sin_addr.s_addr = mybroadcast.sin_addr.s_addr; //printf("Set heartbeat broadcast on %s:%d\n", inet_ntoa(heartbeat_addr.sin_addr), g_xap_port); logEvent(TRUE, "main: Set heartbeat broadcast on %s:%d", inet_ntoa(heartbeat_addr.sin_addr), hubConfig->xap_port); xaptick = time((time_t*)0); heartbeattick = time((time_t*)0); // force heartbeat on startup //printf("Running...\n"); logEvent(TRUE, "main: Running..."); // Parse heartbeat messages received on broadcast interface // If they originated from this host, add the port number to the list of known ports // Otherwise ignore. // If ordinary header then pass to all known listeners while (!flgRestart && (process_state == PROC_RUNNING)) { // Get current time timenow = time((time_t*)0); // Hub tick, check for alive devices if (timenow - xaptick >= 1) { xaphub_tick(timenow - xaptick); xaptick = timenow; } // Heartbeat tick if (timenow >= heartbeattick) { //printf("Outgoing heartbeat tick %d\n",(int)timenow); logEvent(TRUE, "main: Outgoing heartbeat tick %d",(int)timenow); // Create the heartbeat message xaphub_build_heartbeat(heartbeat_msg); //printf("%s", heartbeat_msg); // Send heartbeat to all external listeners sendto(heartbeat_sockfd, heartbeat_msg, strlen(heartbeat_msg), 0, (struct sockaddr *) &heartbeat_addr, sizeof(heartbeat_addr)); // Send heartbeat to all locally connected apps xaphub_relay(tx_sockfd, heartbeat_msg); // Set next tick heartbeattick = timenow + hubConfig->xap_hbeat; } // Prepare to attent to the clients FD_ZERO(&rdfs); FD_SET(server_sockfd, &rdfs); tv.tv_sec = hubConfig->xap_hbeat; tv.tv_usec = 0; select(server_sockfd + 1, &rdfs, NULL, NULL, &tv); // Select either timed out, or there was data - go look for it. client_len = sizeof(struct sockaddr); i = recvfrom(server_sockfd, buff, sizeof(buff), 0, (struct sockaddr*) &client_address, &client_len); // Check if a message was received if (i != -1) { buff[i]='\0'; // Add NULL to the end of message //printf("Message from client %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); logEvent(TRUE, "main: Message from client %s:%d", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port)); // Message from my interface if (client_address.sin_addr.s_addr == myinterface.sin_addr.s_addr) { //printf("Message originated from my interface\n"); // If the message received is a heartbeat message, add the client to the relay list xap_handler(buff); // Relay the message to all local apps, the originator will see his own message xaphub_relay(tx_sockfd, buff); } // Message from local client received else if (client_address.sin_addr.s_addr == inet_addr("127.0.0.1")) { //printf("Message from local client\n"); } // Remote message else { //printf("Message originated remotely, relay\n"); // Relay the message to all local apps xaphub_relay(tx_sockfd, buff); } // Clear message memset(buff, 0, sizeof(buff)); } // Check if has to save settings if (hubConfig->saveFlag) { hubConfig->saveFlag = FALSE; // Reset flag if (saveXmlSettings(SETTINGS_FILE) > 0) { syslog(LOG_ERR, "main: Error saving settings file"); logError("main: Error saving settings file"); } } // Check if has to restart if (hubConfig->restartFlag) { hubConfig->restartFlag = FALSE; // Reset flag flgRestart = TRUE; } } // Restore flgRestart flgRestart = FALSE; // Save xml settings if (saveXmlSettings(SETTINGS_FILE) > 0) { syslog(LOG_ERR, "main: Error saving settings file"); logError("main: Error saving settings file"); } // Build a xAP shutdown message xaphub_build_heartbeat_shutdown(heartbeat_msg); // Send shutdown heartbeat message to all external listeners sendto(heartbeat_sockfd, heartbeat_msg, strlen(heartbeat_msg), 0, (struct sockaddr *) &heartbeat_addr, sizeof(heartbeat_addr)); // Send shutdown heartbeat message to all locally connected apps xaphub_relay(tx_sockfd, heartbeat_msg); // Close xAP communications close(server_sockfd); // Close Server socket close(heartbeat_sockfd); // Close Heartbeat socket close(tx_sockfd); // Close Tx socket } // Close shared memory areas hubSharedMemClose(); // Destroy the process process_finish(); return 0; }