int TCPSocketWindows::OpenTCPSocket(void)
{
CloseTCPSocket();
hSocket = socket(AF_INET, SOCK_STREAM, 0);
if(hSocket == INVALID_SOCKET) {
return -1;
}
SOCKADDR_IN tcp_sock_addr;
memset(&tcp_sock_addr, 0, sizeof(tcp_sock_addr));
tcp_sock_addr.sin_family = AF_INET;
tcp_sock_addr.sin_addr.s_addr = inet_addr(ip.c_str());
tcp_sock_addr.sin_port = htons((short)port);
if(connect(hSocket, (SOCKADDR *)&tcp_sock_addr, sizeof(tcp_sock_addr)) == SOCKET_ERROR) {
CloseTCPSocket();
return -1;
}
int opt_timeout = timeOut;
if(setsockopt(hSocket, SOL_SOCKET, SO_RCVTIMEO, (char*)&opt_timeout, sizeof(opt_timeout)) == SOCKET_ERROR) {
CloseTCPSocket();
return -1;
}
if(setsockopt(hSocket, SOL_SOCKET, SO_SNDTIMEO, (char*)&opt_timeout, sizeof(opt_timeout)) == SOCKET_ERROR) {
CloseTCPSocket();
return -1;
}
return 0;
}
/*------------------------------------------------------------------------------------------------------------*/
void cgi_reset( void * pStruct )
{
struct HTTP_REQUEST * http_request;
http_request = (struct HTTP_REQUEST *) pStruct;
cgi_PrintHttpheaderStart();
if ( http_request->argc == 0 )
{
printf_P( PSTR( "<form action=\"reset.cgi\" method=\"get\" accept-charset=\"ISO-8859-1\">"
"<p><input type=\"submit\" name=\"reset\" value=\"reset\"></p></form>" ));
cgi_PrintHttpheaderEnd();
}
else if( PharseCheckName_P( http_request, PSTR("reset") ) )
{
if ( !strcmp_P( http_request->argvalue[ PharseGetValue_P( http_request, PSTR("reset") ) ] , PSTR("reset") ) )
{
printf_P( PSTR("Reset"));
cgi_PrintHttpheaderEnd();
STDOUT_Flush();
CloseTCPSocket( http_request->HTTP_SOCKET );
softreset();
while(1);
}
}
}
int TCPSocketWindows::SetParameter(string ip, short port, unsigned long timeOut)
{
CloseTCPSocket();
this->ip = ip;
this->port = port;
this->timeOut = timeOut;
return OpenTCPSocket();
}
/*------------------------------------------------------------------------------------------------------------*/
void mp3client_stopstreaming( void )
{
timer0_stop();
// stream offen ?
if ( MP3_SOCKET != NO_SOCKET_USED )
CloseTCPSocket ( MP3_SOCKET );
// Meldung ausgeben
printf_P( PSTR("Connection closed.\r\n") );
// MP3-Puffer leeren
Flush_FIFO( MP3_FIFO );
printf_P( PSTR("FIFO flushed.\r\n") );
STDOUT_Flush();
// socket ungültig setzen
MP3_SOCKET = NO_SOCKET_USED;
}
int main(int argc, char *argv[])
{
int done = FALSE;
opterr = 0;
//fprintf(stderr, "ctrack started.");
c_control = C_RUN;
srand((int)time(NULL));
ErrorInit();
ConfigInit(); // initializes verbose; must be called before any output
ReadConfig(TRUE); // default loc.
TorrentDBCreate();
unsigned int p;
while (!done) {
switch (getopt(argc, argv, "+vqVhrdt:u:p:c:")) { // + means "don't shuffle args"
case '?': // invalid option
PrintSyntax(1);
case 'h': // help option
PrintSyntax(0);
case 'V':
printf("ctrack " VERSION "\n");
return 0;
break;
case 'v':
SetConfigBool(CFG_VERBOSE, TRUE);
log("Verbose mode");
break;
case 'q':
SetConfigBool(CFG_VERBOSE, FALSE);
log("Quiet mode");
break;
case 't':
if (b_assign(atoi(optarg),1,65535,(int *)&p))
SetConfigUInt(CFG_HTTP_PORT, p);
break;
case 'u':
if (b_assign(atoi(optarg),1,65535,(int *)&p))
SetConfigUInt(CFG_UDP_PORT, p);
break;
case 'p':
if (b_assign(atoi(optarg),1,65535,(int *)&p))
SetConfigUInt(CFG_SERVER_PORT, p);
break;
case 'd':
SetConfigBool(CFG_DAEMON, TRUE);
break;
case 'c': //config file
SetConfigString(CFG_CONFIG_FILE, optarg);
ReadConfig(FALSE);
break;
case -1: //end of options
done = TRUE;
break;
default:
PrintSyntax(1);
break;
}//switch
}//while
int i;
for (i = optind; i < argc; i++) {
PTorrentInfo t;
char ibuffer[20];
if (strtohash(argv[i], ibuffer)) {
NewTorrentInfo(&t, ibuffer);
} else {
errorm("Invalid hash: %s", argv[i]);
}
}//for
//TODO:parse args
//TODO:init torrent db
#ifdef DAEMON_SUPPORT
if (GetConfigBool(CFG_DAEMON) == TRUE) {
/* Our process ID and Session ID */
pid_t pid, sid;
/* Fork off the parent process */
pid = fork();
if (pid < 0) { exit(EXIT_FAILURE); }
/* If we got a good PID, then we can exit the parent process. */
if (pid > 0) { exit(EXIT_SUCCESS); }
/* Change the file mode mask */
umask(0);
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
errorm("setsid() failed: %s", str_error());
exit(EXIT_FAILURE);
}
/* Change the current working directory */
if ((chdir("/")) < 0) {
errorm("chdir() failed: %s", str_error());
exit(EXIT_FAILURE);
}
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
if (daemon(TRUE, FALSE) != 0)
errorf(E_SYSTEM, "daemon() failed: %S", str_error());
} else {
extern int asdaemon;
asdaemon = TRUE;
}
#endif
//SetupSignalHandlers
sigset_t set;
int sig;
while (c_control == C_RUN) {
sigfillset(&set);
pthread_sigmask(SIG_SETMASK, &set, NULL);
if (GetConfigBool(CFG_HTTP_SERVER)) { // HTTP server
if (SetUpListener())
HTTPThreadInit();
}
if (GetConfigBool(CFG_UDP_SERVER)) { // UDP server
UDPThreadInit();
}
//TODO: sigwait
while (c_control == C_RUN) {
sigwait(&set, &sig);
logf("Caught signal #%d", sig);
switch (sig) {
case SIGINT:
c_control = C_TERMINATE;
log("Exitting...");
break;
case SIGHUP:
c_control = C_RESTART;
log("Restarting...");
ReadConfig(FALSE);
break;
case SIGSEGV:
c_control = C_TERMINATE;
log("Exitting...");
}//switch
}//while
ThreadsDestroy();
CloseTCPSocket();
CloseUDPSocket();
if (c_control == C_RESTART) { c_control = C_RUN; }
}//while
log("exit ");
return ((sig==SIGINT) ? EXIT_SUCCESS : EXIT_FAILURE);
}
TCPSocketWindows::~TCPSocketWindows(void)
{
CloseTCPSocket();
WSACleanup();
}
/*------------------------------------------------------------------------------------------------------------*/
void telnet_thread()
{
static struct TELNET_SESSION telnet_session;
struct STDOUT oldstream;
char Data;
int i;
// keine alte Verbindung offen?
if ( telnet_session.SOCKET == NO_SOCKET_USED )
{
// auf neue Verbindung testen
telnet_session.SOCKET = CheckPortRequest( TELNET_PORT );
if ( telnet_session.SOCKET != NO_SOCKET_USED )
{
STDOUT_save( &oldstream );
STDOUT_set( _TCP, telnet_session.SOCKET );
// Wenn ja, Startmeldung ausgeben und startzustand herstellen für telnet
printf_P( PSTR( "Welcome on Tiny-Telnetserver 0.2!\r\n"
"Und, los geht's...!!! (\"help\" hilft :-))\r\n> " ));
STDOUT_restore( &oldstream );
// TELNET_BUFFER leeren und auf Ausgangszustand setzen
telnet_session.STATE = 0;
telnet_session.POS = 0;
telnet_session.BUFFER[0] = '\0';
telnet_session.STATE = 0;
FlushSocketData( telnet_session.SOCKET );
}
}
// Wenn alte Verbindung offen hier weiter:
else
{
// checken, ob noch offen ist
if( CheckSocketState( telnet_session.SOCKET ) == SOCKET_NOT_USE )
{
CloseTCPSocket( telnet_session.SOCKET );
telnet_session.SOCKET = NO_SOCKET_USED;
return;
}
// Auf neue Daten zum zusammenbauen testen
// hier wird der TELNET_BUFFER aufgefüllt bis 0x0a oder 0x0d eintreffen. der Puffer ist statisch
// Wenn ein 0x0a oder 0x0d empfangen wurde, wird der TELNET_STATE auf 1 gesetzt, damit er verarbeitet werden kann
if ( telnet_session.STATE == 0 )
{
while( GetBytesInSocketData( telnet_session.SOCKET ) >= 1 )
{
Data = ( GetByteFromSocketData ( telnet_session.SOCKET ) );
if ( Data != 0x0a && Data <= 0x7f)
{
if ( telnet_session.POS < TELNET_BUFFER_LEN )
{
telnet_session.BUFFER[ telnet_session.POS++ ] = Data;
telnet_session.BUFFER[ telnet_session.POS ] = '\0';
}
if ( Data == 0x0d )
{
telnet_session.STATE = 1;
break;
}
}
}
}
// Wenn TELNET_BUFFER eine Zeile vollständig hat gehts hier weiter
if ( telnet_session.STATE == 1 )
{
STDOUT_save( &oldstream );
STDOUT_set( _TCP, telnet_session.SOCKET );
telnet_session.argc = TELNET_pharse( telnet_session.BUFFER, telnet_session.argv, MAX_ARGC );
TELNET_runcmd( telnet_session.argc, telnet_session.argv );
// auf QUIT checken
if ( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("quit") ) )
{
// Socket schließen
printf_P( PSTR("Verbindung wird geschlossen\r\n") );
STDOUT_Flush();
STDOUT_set( RS232, 0);
CloseTCPSocket( telnet_session.SOCKET );
telnet_session.SOCKET = NO_SOCKET_USED;
return;
}
else if( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("help") ) )
{
printf_P( PSTR("Folgende Befehle sind vorhanden:\r\n\r\n") );
for( i = 0 ; i < MAX_TELNET_ENTRYS ; i++ )
{
if ( telnet_cmd_table[ i ].functionname != NULL )
{
printf_P( telnet_cmd_table[ i ].functionname );
printf_P( PSTR("\r\n") );
}
}
}
printf_P( PSTR("> ") );
STDOUT_restore( &oldstream );
telnet_session.STATE = 0;
telnet_session.POS = 0;
telnet_session.BUFFER[0] = '\0';
telnet_session.STATE = 0;
}
}
}
/**
* \brief Der Telnet-client an sich. Er wird zyklisch aufgerufen und schaut nach ob eine Verbindung auf den
* registrierten Port eingegangen ist. Wenn ja holt er sich die Socketnummer der Verbindung und speichert diese.
* Wenn eine Verbindung zustande gekommen ist wird diese wiederrum zyklisch nach neuen Daten abgefragt und entsprechend
* reagiert.
* \param NONE
* \return NONE
*/
void telnet_thread( void )
{
struct STDOUT oldstream;
char Data;
// keine alte Verbindung offen?
if ( telnet_session.SOCKET == NO_SOCKET_USED )
{
// auf neue Verbindung testen
telnet_session.SOCKET = CheckPortRequest( TELNET_PORT );
if ( telnet_session.SOCKET != NO_SOCKET_USED )
{
STDOUT_save( &oldstream );
STDOUT_set( _TCP, telnet_session.SOCKET );
// Wenn ja, Startmeldung ausgeben und startzustand herstellen für telnet
printf_P( PSTR( "Und, los geht's...!!! (\"help\" hilft :-))\r\n> " ));
STDOUT_restore( &oldstream );
// TELNET_BUFFER leeren und auf Ausgangszustand setzen
telnet_session.STATE = 0;
telnet_session.POS = 0;
telnet_session.BUFFER[0] = '\0';
telnet_session.STATE = 0;
FlushSocketData( telnet_session.SOCKET );
}
}
// Wenn alte Verbindung offen hier weiter:
else
{
// checken, ob noch offen ist
if( CheckSocketState( telnet_session.SOCKET ) != SOCKET_READY )
{
telnet_session.SOCKET = NO_SOCKET_USED;
return;
}
// Auf neue Daten zum zusammenbauen testen
// hier wird der TELNET_BUFFER aufgefüllt bis 0x0a oder 0x0d eintreffen. der Puffer ist statisch
// Wenn ein 0x0a oder 0x0d empfangen wurde, wird der TELNET_STATE auf 1 gesetzt, damit er verarbeitet werden kann
if ( telnet_session.STATE == 0 )
{
while( GetBytesInSocketData( telnet_session.SOCKET ) >= 1 )
{
Data = ( GetByteFromSocketData ( telnet_session.SOCKET ) );
if ( Data != 0x0a && Data <= 0x7f)
{
if ( telnet_session.POS < TELNET_BUFFER_LEN )
{
telnet_session.BUFFER[ telnet_session.POS++ ] = Data;
telnet_session.BUFFER[ telnet_session.POS ] = '\0';
}
if ( Data == 0x0d )
{
telnet_session.STATE = 1;
break;
}
}
}
}
// Wenn TELNET_BUFFER eine Zeile vollständig hat gehts hier weiter
if ( telnet_session.STATE == 1 )
{
STDOUT_save( &oldstream );
STDOUT_set( _TCP, telnet_session.SOCKET );
telnet_session.argc = SHELL_pharse( telnet_session.BUFFER, telnet_session.argv, MAX_ARGC );
// auf QUIT checken
if ( !strcmp_P( telnet_session.argv[ 0 ] , PSTR("quit") ) )
{
// Socket schließen
printf_P( PSTR("Quiting\r\n") );
STDOUT_Flush();
STDOUT_set( RS232, 0);
CloseTCPSocket( telnet_session.SOCKET );
telnet_session.SOCKET = NO_SOCKET_USED;
return;
} else
/************************************************************************/
/* help value for openhab just intended to simulate a connection */
/************************************************************************/
if(!strcmp_P( telnet_session.argv[ 0 ] , PSTR("value") )){
printf_P( PSTR("openhab") );
STDOUT_Flush();
}
else
{
SHELL_runcmd( telnet_session.argc, telnet_session.argv );
}
printf_P( PSTR("> ") );
STDOUT_restore( &oldstream );
telnet_session.STATE = 0;
telnet_session.POS = 0;
telnet_session.BUFFER[0] = '\0';
telnet_session.STATE = 0;
}
}
}
/*------------------------------------------------------------------------------------------------------------*/
void mp3client_stream( void )
{
static unsigned int temp;
char sreg_tmp;
timer0_stop();
// Wenn slowstart auf 0 steht Decoder nicht befüttern, sonst warten bis 7/8 voll
if ( slowstart == 0 )
VS10xx_flush_from_FIFO( MP3_FIFO );
else
if ( Get_Bytes_in_FIFO ( MP3_FIFO ) > ( mp3_buffer_size / 8 ) * 7 ) slowstart = 0;
// Verbindung wirklich noch offen
if( CheckSocketState( MP3_SOCKET ) == SOCKET_NOT_USE )
{
CloseTCPSocket( MP3_SOCKET );
MP3_SOCKET = NO_SOCKET_USED;
}
else
{
sreg_tmp = SREG;
sei();
// Datenpuffer auffrischen mit neuen daten von TCP-Verbindung
while ( GetBytesInSocketData( MP3_SOCKET ) >= MP3TCPtranslen && Get_FIFOrestsize ( MP3_FIFO ) > MP3TCPtranslen && metainfolen == 0 )
{
// Wenn die transferlänge zum nächsten Metaint kleiner als translen zwischen tcp und mp3 buffer ist, nur diese
// kopieren damit danach der metaint eingelesen werden kann
if ( metaint - ( metaintcounter%metaint ) < MP3TCPtranslen && metaint != 0)
{
LED_on(1);
temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, metaint - ( metaintcounter%metaint ) );
totalbytes = totalbytes + temp;
metaintcounter = metaintcounter + temp;
LED_off(1);
}
else
{
LED_on(1);
temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, MP3TCPtranslen );
totalbytes = totalbytes + temp;
metaintcounter = metaintcounter + temp;
LED_off(1);
}
if ( metaintcounter%metaint == 0 && metaint != 0 )
{
// checkt und wartet ob mehr als 1 Byte im Puffer ist
while ( GetBytesInSocketData( MP3_SOCKET ) <= 0 );
// lese Byte und errechne die metalänge
metainfolen = GetByteFromSocketData ( MP3_SOCKET ) * 16 ;
break;
}
}
SREG = sreg_tmp;
}
timer0_free();
}
/*------------------------------------------------------------------------------------------------------------*/
void mp3client_thread( void )
{
#define bandwidthhis 16
unsigned char i;
static unsigned long totalbytesold[bandwidthhis],bandwidth;
static unsigned char y;
static unsigned int temp;
timer0_stop();
STDOUT_Set_RS232 ();
if ( MP3_SOCKET == NO_SOCKET_USED )
{
// keine Verbindung offen? Trafficcounter zurücksetzen
y=0;
metaintcounter=0;
slowstart = 1;
}
else
{
// Verbindung wirklich noch offen
if( CheckSocketState( MP3_SOCKET ) == SOCKET_NOT_USE )
{
CloseTCPSocket( MP3_SOCKET );
MP3_SOCKET = NO_SOCKET_USED;
}
else
{
// Wenn Puffer auf unter 1/8 gelaufen ist slowstart setzen
if ( Get_Bytes_in_FIFO ( MP3_FIFO ) < mp3_buffer_size / 8 ) slowstart = 1;
/* // Datenpuffer auffrischen mit neuen daten von TCP-Verbindung
while ( GetBytesInSocketData( MP3_SOCKET ) >= MP3TCPtranslen && Get_FIFOrestsize ( MP3_FIFO ) > MP3TCPtranslen && metainfolen == 0 )
{
// Wenn die transferlänge zum nächsten Metaint kleiner als translen zwischen tcp und mp3 buffer ist, nur diese
// kopieren damit danach der metaint eingelesen werden kann
if ( metaint - ( metaintcounter%metaint ) < MP3TCPtranslen && metaint != 0)
{
LED_on(1);
temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, metaint - ( metaintcounter%metaint ) );
totalbytes = totalbytes + temp;
metaintcounter = metaintcounter + temp;
LED_off(1);
}
else
{
LED_on(1);
temp = GetSocketDataToFIFO ( MP3_SOCKET, MP3_FIFO, MP3TCPtranslen );
totalbytes = totalbytes + temp;
metaintcounter = metaintcounter + temp;
LED_off(1);
}
if ( metaintcounter%metaint == 0 && metaint != 0 )
{
// checkt und wartet ob mehr als 1 Byte im Puffer ist
while ( GetBytesInSocketData( MP3_SOCKET ) <= 0 );
// lese Byte und errechne die metalänge
metainfolen = GetByteFromSocketData ( MP3_SOCKET ) * 16 ;
break;
}
}
*/
// Wenn der metaintcounter auf einen metaint steht, den metaint lesen und ausgeben
if ( metainfolen != 0 )
{
mp3client_readmetainfo( MP3_SOCKET, metainfolen );
metainfolen = 0;
}
// Counter schon bei 0, wenn ja stats updaten
if ( CLOCK_GetCountdownTimer ( mp3timer ) == 0 )
{
bandwidth = 0;
// traffic aufaddieren
for ( i = 0 ; i < bandwidthhis ; i++)
bandwidth = bandwidth + totalbytesold[ i ];
// bandwidth berechnen alle 0,5 sekunden
bandwidth = ( bandwidth / bandwidthhis ) * 2;
// stats sichern
mp3clientupdate( bandwidth, GetBytesInSocketData( MP3_SOCKET ) , Get_Bytes_in_FIFO ( MP3_FIFO ), VS10xx_get_decodetime( ), verboselevel );
// wenn verboselevel gesetzt ausgeben
if ( verboselevel != 0)
printf_P( PSTR("\r%5d(TCP %4d)Bytes on FIFO, bandwidth:%3ldkbit/s(%2dkb/s)"), Get_Bytes_in_FIFO ( MP3_FIFO ), GetBytesInSocketData( MP3_SOCKET ), ( bandwidth * 8 ) / 1024, ( bandwidth * 8 ) / 8192 );
// zähler für bandwidth zurücksetzten
if ( y < bandwidthhis )
{
totalbytesold[y] = totalbytes;
}
else
{
y = 0;
totalbytesold[y] = totalbytes;
}
y++;
totalbytes = 0;
// Counter neu starten 0,5 Sekunden
CLOCK_SetCountdownTimer ( mp3timer, 47, MSECOUND );
}
}
}
timer0_free();
return;
}
/* Download CEPT-Hypertext Page from Ulm */
int applicationBtxHttpGet(char *url, unsigned long ulmIp ,char *data, int *status)
{
volatile unsigned int httpServerSocket = NO_SOCKET_USED;
char dataByte;
char *dataPointer = data;
unsigned char timeoutTimerHandle;
int dataCount = 0; /* Counter to prevent buffer overflows */
/* Pass 1: Establish server connection */
httpServerSocket = Connect2IP(ulmIp,BTX_ULM_PORT); /* Connect http-server (Ulm) */
if(httpServerSocket == NO_SOCKET_USED)
return -1; /* Connection failed */
/* Pass 2: Perform HTTP-Request */
STDOUT_Set_TCP_Socket(httpServerSocket);
printf_P(PSTR("GET %s HTTP/1.0\r\nHost: " BTX_ULM_HOST "\r\n\r\n"),url);
STDOUT_Flush();
if(httpServerSocket == NO_SOCKET_USED)
return -1; /* Connection closed unexpectetly */
timeoutTimerHandle = CLOCK_RegisterCoundowntimer(); /* Register timer */
while(GetBytesInSocketData(httpServerSocket) == 0); /* Trigger on incoming data */
while(GetBytesInSocketData(httpServerSocket) > 0)
{
dataByte = GetByteFromSocketData(httpServerSocket);
if(dataCount < BTX_CEPT_HYPERTEXT_BUFFERSIZE-1)
{
*dataPointer = dataByte;
dataPointer++;
dataCount++;
}
/* Handle connection timeout (3 retrys) */
if(GetBytesInSocketData(httpServerSocket) == 0)
{
CLOCK_SetCountdownTimer (timeoutTimerHandle, 8, MSECOUND );
while(CLOCK_GetCountdownTimer(timeoutTimerHandle) > 0);
if(GetBytesInSocketData(httpServerSocket) == 0)
{
CLOCK_SetCountdownTimer (timeoutTimerHandle, 16, MSECOUND );
while(CLOCK_GetCountdownTimer(timeoutTimerHandle) > 0);
if(GetBytesInSocketData(httpServerSocket) == 0)
{
CLOCK_SetCountdownTimer (timeoutTimerHandle, 32, MSECOUND );
while(CLOCK_GetCountdownTimer(timeoutTimerHandle) > 0);
if(GetBytesInSocketData(httpServerSocket) == 0)
break;
}
}
}
}
CLOCK_ReleaseCountdownTimer(timeoutTimerHandle); /* Free timer */
*dataPointer = '\0'; /* Add a 0 to make the string functions happy */
*status = atoi(&data[8]); /* Calculate status code */
CloseTCPSocket (httpServerSocket); /* Close connection */
STDOUT_Set_RS232(); /* Set STDOUT to console */
return 0;
}
