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;
}
