dockapps/wmisdn/wmisdn.cc

/*   wmisdn - an ISDN monitor applet for windowmaker/afterstep
 *   Copyright (c) 2000-2001 Tasho Statev Kaletha
 *   tasho.kaletha@gmx.de
 * 
 * 
 *   This program is free software; you can redistribute it and/or modify        
 *   it under the terms of the GNU General Public License as published by        
 *   the Free Software Foundation; either version 2 of the License, or           
 *   (at your option) any later version.                                         
 *                                                                               
 *   This program is distributed in the hope that it will be useful,             
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of              
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               
 *   GNU General Public License for more details.                                
 */


/* these defaults can be changed by command line options. */
#define WINDOWMAKER false
#define USESHAPE false
#define NAME "wmisdn"
#define CLASS "WMIsdn"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <ctype.h>
#include <math.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <net/if.h>
#include <netinet/in.h>
#include <syslog.h>
#include <asm/errno.h> /* for ENOTCONN */
#include <errno.h>

#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xproto.h>
#include <X11/xpm.h>
#include <X11/extensions/shape.h>

#include <linux/isdn.h>
#include <linux/isdnif.h>
#include <time.h>

#include "regions.h"
#include "optics/optics.h"

static Pixmap coverPixmap;
static Pixmap unknownPixmap;
static Pixmap dialingPixmap;
static Pixmap offPixmap;
static Pixmap disabledPixmap;
static Pixmap statusPixmaps[6];
static Pixmap incomingPixmap, outgoingPixmap, bundlingPixmap, bundledPixmap, slavePixmap;


static Pixmap ledsPixmap;		/* a row of led symbols as shown by the var led_text below */
static Pixmap lampsPixmap;	/* a row of lamp images - green off, green on, yellow off, yellow on, red off, red on */
static Pixmap infoSWPixmap;	/* a row of arrows - left off, left on, right off, right on */
static Pixmap lampsSWPixmap;	/* a row of arrows - up off, up on, down off, down on */

#include "xpm/unknown.xpm"
#include "xpm/disabled.xpm"
#include "xpm/off.xpm"
#include "xpm/offline.xpm"
#include "xpm/dialing.xpm"
#include "xpm/incoming.xpm"
#include "xpm/outgoing.xpm"
#include "xpm/bundling.xpm"
#include "xpm/bundled.xpm"
#include "xpm/slave.xpm"
#include "xpm/raw.xpm"
#include "xpm/modem.xpm"
#include "xpm/online.xpm"
#include "xpm/voice.xpm"
#include "xpm/fax.xpm"

#include "xpm/cover.xpm"
#include "xpm/leds.xpm"
#include "xpm/lamps.xpm"
#include "xpm/lamps_sw.xpm"
#include "xpm/info_sw.xpm"

/* Runtime pixmaps */
static Pixmap disp_info;	/* double buffer for the info panel */
static Pixmap disp;			/* for the main window */
static Pixmap dmsk;			/* clip mask for the main window */

/* For command line arguments */
#define MAX_ARG_LEN		256
static bool wmaker = WINDOWMAKER;
static bool ushape = USESHAPE;
static char txtdpy[MAX_ARG_LEN] = "";
static char txtfont[MAX_ARG_LEN] = "";
static int  dialmode = ISDN_NET_DM_AUTO;
static char devices[ISDN_MAX_CHANNELS][MAX_ARG_LEN];
static int selected_device=-1;		/* selected device, points to an element of devices[] */
static char scriptpath[MAX_ARG_LEN] = "/etc/isdn";
static int scriptmode = 0;
static bool usescripts = false;
static int maxscriptmode = 0;
static char** scriptmodestrings = NULL;
static char *slave_pending = NULL;

/* atoms for deleting window */
static Atom _XA_GNUSTEP_WM_FUNC;
static Atom WM_DELETE_WINDOW;

/* global variables */
Display *dpy;
Window Win[3];				/* 0 - main win, 1 - icon win (for wmaker), 2 - info panel */
Window Root;
GC WinGC;
int activeWin;
XFontStruct *textFont=NULL;

static char led_text[] = "0123456789?/\\!@#$%^&*()_+-=\"~<>[]{}:. abcdefghijklmnopqrstuvwxyz";


static int rootUID, rootGID;
static bool infoPanelActive = false;
static bool lampsActive = false;

/* Der scriptmode wird als 2. Argument den Start-/Stopskripten uebergeben.
   Aenderung mit mittlerer Maustaste auf InfoSw bei offenem Infopanel. */

#define ACTIVE			1	/* values are not only symbolc, but important for calculations! */
#define INACTIVE		0
#define ID_LAMP_GREEN	0
#define ID_LAMP_YELLOW	1
#define ID_LAMP_RED		2

#define ID_SWITCH_INFO	10
#define ID_SWITCH_LAMPS	11
#define ID_SWITCH_STATUS 19
#define ID_DEVICE		20

#define UPDATE_INTERVAL 20  /* how many 50 milisec intervalls to wait between updates */
#define STATUS_WARNING_SAT 5 /* how many times to display a warning upon failing to retrieve device stats */

#define INCOMING		0
#define OUTGOING		1
#define STAT_DISABLED	1000
#define STAT_OFF		1001
#define STAT_DIALING	1002
#define STAT_UNKNOWN	2001
#define STAT_UNINITIALIZED 2002

#define SCRIPT_UP		"wmisdn-up"
#define SCRIPT_DOWN		"wmisdn-down"
#define SCRIPT_MODES	"wmisdn-scriptmodes"

typedef enum mpppModeType { none, master, slave };

struct isdnStatus
{
	int usage;
	int direction;
	bool bundled;
	char peerPhone[100];
	mpppModeType  mpppMode;
	char mpppPartner[100];
} curStatus = { STAT_UNINITIALIZED, INCOMING, false, "", none, "" };



/* text i/o routines */
bool scanArgs(int argc, char *argv[]);
void printUsage( char *prog_name );
void printHeader();
void parseDeviceNames( char *name_list );
void readScriptModes();


/* init/done routines */
void initXWin(int argc, char *argv[]);
void freeXWin();
void createMainWin( Window *win );
void createInfoPanel( Window *win );
void loadPixmaps();
void freePixmaps();
void createRegions();


/* window routines */
void alignInfoPanel();
void getWindowPosition( Window win, int *x, int *y );
void getWindowDimension( Window win, int *w, int *h );

/* graphic routines */
unsigned long getColor(const char *colorname);
void createPixmap(char *data[], Pixmap *image, Pixmap *mask );
void loadLeds(char *data[], Pixmap *image, const char *leds_color, const char *back_color );
void drawText( char *text, Pixmap dst, int x, int y, const char *color=InfoTextColor );
void drawLamp( int index, int active );
void drawDevice( int active = INACTIVE );
unsigned long mixColor( const char *colorname1, int prop1, const char *colorname2, int prop2);

/* interaction routines */
bool timeToUpdate();
void update();
void fullRepaint();
void repaint( Window win, int x, int y, int w, int h );
void setStatusPixmap();
void updateInfoPanel();
void blankMainWin( int x=0, int y=0, int w=MainWinDim.w, int h=MainWinDim.h );
void pressLamp( int lamp, int button );
void pressStatusSw();
void activateLamps( bool active );
void drawSwitches();

/* region event handlers */
void mouseInLamp( int id );
void mouseOutLamp( int id );
void mouseClickLamp( int id, unsigned int button );
void mouseInInfoSw( int id );
void mouseOutInfoSw( int id );
void mouseClickInfoSw( int id, unsigned int button );
void mouseInLampsSw( int id );
void mouseOutLampsSw( int id );
void mouseClickLampsSw( int id, unsigned int button );
void mouseInDevice( int id );
void mouseOutDevice( int id );
void mouseClickDevice( int id, unsigned int button );
void mouseInStatusSw( int id );
void mouseOutStatusSw( int id );
void mouseClickStatusSw( int id, unsigned int button );


void selectNextDevice();

/* event handlers */
void exposeEvent( XExposeEvent *xev);
void pressEvent(XButtonEvent *xev);
void motionEvent( XMotionEvent *xev );

/* ISDN routines */
void getStatus( char *device, isdnStatus *stat );
void getLocalIP( int *a, int *b, int *c, int *d );
inline void getRemoteIP( int *a, int *b, int *c, int *d );
inline void translateIP( struct sockaddr *addr, int *a, int *b, int *c, int *d );
int isdn_ioctl( int func, void *arg, const char *errmsg, const char *filename="/dev/isdnctrl" );
void isdnInitDefaultDialmode();
int getIpppNum( char *name );

inline void set_slave_pending();
inline void clear_slave_pending();
inline bool is_slave_pending();
inline void manage_slave();

/* -------- Implementation ----------- */

int main(int argc, char *argv[])
{

	rootUID = geteuid(); rootGID = getegid();
	seteuid(getuid()); setegid(getgid());

	printHeader();
	if( !scanArgs(argc, argv) )
	{
		printUsage( argv[0] );
		return 1;
	}
	readScriptModes();
	
	initXWin(argc, argv);
   
	loadPixmaps();
	createRegions();
	disp = XCreatePixmap(dpy, Root, MainWinDim.w, MainWinDim.h, DefaultDepth(dpy,DefaultScreen(dpy)));
	disp_info = XCreatePixmap(dpy, Root, InfoWinDim.w, InfoWinDim.h, DefaultDepth(dpy,DefaultScreen(dpy)));	

	XGCValues gcv;
	unsigned long gcm;
	gcm = GCGraphicsExposures|GCBackground;
	gcv.graphics_exposures = True; 
	gcv.background = getColor( WindowBackgroundColor );	
	if( strlen(txtfont) != 0 )
	{
		textFont = XLoadQueryFont( dpy, txtfont );
		if( textFont != NULL )
		{
			gcm |= GCFont;
			gcv.font = textFont->fid;
		} else
			syslog( LOG_NOTICE, "Couldn't load specified font" );
	}
	WinGC = XCreateGC(dpy, Root, gcm, &gcv);

	blankMainWin();
	drawDevice(INACTIVE);
	activateLamps( lampsActive );
	drawSwitches();
	update();

	if(!(wmaker || ushape))
		XSetClipMask(dpy, WinGC, dmsk);
	else
		XShapeCombineMask(dpy, Win[activeWin], ShapeBounding, 0, 0, dmsk, ShapeSet);		
	
	XSetClipOrigin(dpy, WinGC, 0, 0);
	XSetClipMask(dpy, WinGC, None);

	XEvent event;
	XSelectInput(dpy, Win[activeWin], PointerMotionMask | ButtonPress | ExposureMask);
	XSelectInput(dpy, Win[2], ExposureMask );
	XMapWindow(dpy, Win[0]);

	bool finished=false;
	while(!finished){
		while(XPending(dpy)){
			XNextEvent(dpy,&event);
			switch(event.type){
				case ButtonPress : pressEvent(&event.xbutton); break;
				case MotionNotify : motionEvent(&event.xmotion); break;
				
				case ClientMessage :
					if((Atom)event.xclient.data.l[0]==WM_DELETE_WINDOW)
						finished=true;
					break;
				
				case Expose : exposeEvent( &event.xexpose ); break;
			}
		}
		if( timeToUpdate() )
		{
			update();
			manage_slave();
		}
		usleep(50000);
	}

	if( textFont != NULL )
		XFreeFont( dpy, textFont );
	XFreeGC(dpy, WinGC);
	freePixmaps();
	/* Free runtime pixmaps */
	XFreePixmap(dpy, disp_info);
	XFreePixmap(dpy, disp);
	XFreePixmap(dpy, dmsk);
	/* Finish with X stuff */
	freeXWin();
	return 0;
}

void initXWin(int argc, char *argv[])
{
	if( (dpy=XOpenDisplay(txtdpy)) == NULL )
	{
		fprintf(stderr,"cannot open display!\n");
		exit(1);
	}
	_XA_GNUSTEP_WM_FUNC = XInternAtom(dpy, "_GNUSTEP_WM_FUNCTION", false);
	WM_DELETE_WINDOW = XInternAtom(dpy, "WM_DELETE_WINDOW", false);
	Root=DefaultRootWindow(dpy);
	createMainWin(&Win[0]);
	createMainWin(&Win[1]);
	createInfoPanel( &Win[2] );
	XWMHints hints;
	XSizeHints shints;
	hints.window_group = Win[0];
	shints.min_width=64;
	shints.min_height=64;
	shints.max_width=64;
	shints.max_height=64;
	shints.x=0;
	shints.y=0;
	if(wmaker)
	{
		hints.initial_state = WithdrawnState;
		hints.icon_window = Win[1];
		hints.flags = WindowGroupHint | StateHint | IconWindowHint;
		shints.flags = PMinSize | PMaxSize | PPosition;
		activeWin=1;
	}
	else {
		hints.initial_state = NormalState;
		hints.flags = WindowGroupHint | StateHint;
		shints.flags = PMinSize | PMaxSize;
		activeWin=0;
	}
	XSetWMHints(dpy, Win[0], &hints);
	XSetWMNormalHints(dpy, Win[0], &shints);
	XSetCommand(dpy, Win[0], argv, argc);
	XStoreName(dpy, Win[0], NAME);
	XSetIconName(dpy, Win[0], NAME);
	XSetWMProtocols(dpy, Win[activeWin], &WM_DELETE_WINDOW, 1);
}

void freeXWin()
{
	XDestroyWindow(dpy, Win[0]);
	XDestroyWindow(dpy, Win[1]);
	XDestroyWindow(dpy, Win[2]);
	XCloseDisplay(dpy);
}

void loadPixmaps()
{
	createPixmap(cover_xpm, &coverPixmap, &dmsk );
	createPixmap(dialing_xpm, &dialingPixmap, NULL );		
	createPixmap(unknown_xpm, &unknownPixmap, NULL );		
	createPixmap(disabled_xpm, &disabledPixmap, NULL );			
	createPixmap(off_xpm, &offPixmap, NULL );

	createPixmap(incoming_xpm, &incomingPixmap, NULL );
	createPixmap(outgoing_xpm, &outgoingPixmap, NULL );
	createPixmap(bundling_xpm, &bundlingPixmap, NULL );
	createPixmap(bundled_xpm, &bundledPixmap, NULL );	
	createPixmap(slave_xpm, &slavePixmap, NULL );		
	
	createPixmap(offline_xpm, &statusPixmaps[ISDN_USAGE_NONE], NULL );
	createPixmap(raw_xpm, &statusPixmaps[ISDN_USAGE_RAW], NULL );	
	createPixmap(modem_xpm, &statusPixmaps[ISDN_USAGE_MODEM], NULL );		
	createPixmap(online_xpm, &statusPixmaps[ISDN_USAGE_NET], NULL );	
	createPixmap(voice_xpm, &statusPixmaps[ISDN_USAGE_VOICE], NULL );		
	createPixmap(fax_xpm, &statusPixmaps[ISDN_USAGE_FAX], NULL );	
	
	createPixmap(lamps_xpm, &lampsPixmap, NULL );
	createPixmap(info_sw_xpm, &infoSWPixmap, NULL );
	createPixmap(lamps_sw_xpm, &lampsSWPixmap, NULL );	
	loadLeds( leds_xpm, &ledsPixmap, InfoTextColor, WindowBackgroundColor );	
}

void freePixmaps()
{
	XFreePixmap(dpy, coverPixmap);	
	XFreePixmap(dpy, dialingPixmap);		
	XFreePixmap(dpy, unknownPixmap);
	XFreePixmap(dpy, disabledPixmap);	
	XFreePixmap(dpy, offPixmap);
	
	XFreePixmap(dpy, incomingPixmap);
	XFreePixmap(dpy, outgoingPixmap);
	XFreePixmap(dpy, bundlingPixmap);
	XFreePixmap(dpy, bundledPixmap);
	XFreePixmap(dpy, slavePixmap);	

	for( int i=ISDN_USAGE_NONE; i < ISDN_USAGE_FAX; i++ )
		XFreePixmap( dpy, statusPixmaps[i] );

	XFreePixmap(dpy, ledsPixmap);
	XFreePixmap(dpy, lampsPixmap);
	XFreePixmap(dpy, infoSWPixmap);
	XFreePixmap(dpy, lampsSWPixmap);	
}

void createMainWin( Window *win )
{
	*win = XCreateSimpleWindow(dpy, Root, 10, 10, MainWinDim.w, MainWinDim.h,0,0,0);

	XClassHint classHint;	
	classHint.res_name = NAME;
	classHint.res_class = CLASS;
	XSetClassHint(dpy, *win, &classHint);
}

void createInfoPanel( Window *win )
{
	*win = XCreateSimpleWindow(dpy, Root, 10, 10, InfoWinDim.w, InfoWinDim.h,0,0,0);

	XSizeHints shints;
	shints.flags = PPosition;
	XSetWMNormalHints( dpy, *win, &shints );
	
	XClassHint classHint;	
	classHint.res_name = "Info";
	classHint.res_class = CLASS;
	XSetClassHint(dpy, *win, &classHint);
}

void createRegions()
{
	region_init(dpy);

	region_add( Win[activeWin], ID_LAMP_GREEN, LampsRect[ID_LAMP_GREEN].pos.x, LampsRect[ID_LAMP_GREEN].pos.y, LampsRect[ID_LAMP_GREEN].dim.w, LampsRect[ID_LAMP_GREEN].dim.h, mouseInLamp, mouseOutLamp, mouseClickLamp );
	region_add( Win[activeWin], ID_LAMP_YELLOW, LampsRect[ID_LAMP_YELLOW].pos.x, LampsRect[ID_LAMP_YELLOW].pos.y, LampsRect[ID_LAMP_YELLOW].dim.w, LampsRect[ID_LAMP_YELLOW].dim.h, mouseInLamp, mouseOutLamp, mouseClickLamp );
	region_add( Win[activeWin], ID_LAMP_RED, LampsRect[ID_LAMP_RED].pos.x, LampsRect[ID_LAMP_RED].pos.y, LampsRect[ID_LAMP_RED].dim.w, LampsRect[ID_LAMP_RED].dim.h, mouseInLamp, mouseOutLamp, mouseClickLamp );
	
	region_add( Win[activeWin], ID_SWITCH_INFO, InfoSWRect.pos.x, InfoSWRect.pos.y, InfoSWRect.dim.w, InfoSWRect.dim.h, mouseInInfoSw, mouseOutInfoSw, mouseClickInfoSw );
	region_add( Win[activeWin], ID_SWITCH_LAMPS, LampsSWRect.pos.x, LampsSWRect.pos.y, LampsSWRect.dim.w, LampsSWRect.dim.h, mouseInLampsSw, mouseOutLampsSw, mouseClickLampsSw );	

	region_add( Win[activeWin], ID_DEVICE, DeviceRect.pos.x, DeviceRect.pos.y, DeviceRect.dim.w, DeviceRect.dim.h, mouseInDevice, mouseOutDevice, mouseClickDevice );
	region_add( Win[activeWin], ID_SWITCH_STATUS, StatusPixmapRect.pos.x, StatusPixmapRect.pos.y, StatusPixmapRect.dim.w, StatusPixmapRect.dim.h, mouseInStatusSw, mouseOutStatusSw, mouseClickStatusSw );
}

bool validIppp( char *name )
{
	if( strlen(name) < 5 )
		return false;
	if( strncmp( name, "ippp", 4 ) != 0 )
		return false;
	for( char *p=name+4; *p != '\x0'; p++ )
		if( !isdigit(*p) )
			return false;
	if( getIpppNum(name) >= ISDN_MAX_CHANNELS )
		return false;
	return true;
}

int getIpppNum( char *name )
{
	return atoi( name + 4 );
}

void selectNextDevice()
{
	selected_device++;
	if( devices[selected_device][0] == 0 )
		selected_device = 0;
	drawDevice();
	update();
}

void printUsage( char *prog_name )
{
	fprintf( stderr, "usage:\n\n   %s [options]\n\noptions:\n\n", prog_name );
	fprintf( stderr, "   -h | -help | --help    display this help screen\n");
	fprintf( stderr, "   -w                     use WithdrawnState (for WindowMaker)\n" );
	fprintf( stderr, "   -s                     shaped window\n" );
	fprintf( stderr, "   -display display       select target display (see X manual pages)\n" );
	fprintf( stderr, "   -font font             select the font for displaying status information\n" );	
	fprintf( stderr, "   -dialmode mode         select dial mode for offline mode (auto or manual)\n" );
	fprintf( stderr, "   -device device         select ippp devices to monitor\n" );
	fprintf( stderr, "                           (a list of comma-separated device names is expected containing __no blanks__)\n" );
	fprintf( stderr, "   -lamps                 activate the line control switches upon startup\n" );
	fprintf( stderr, "   -usescripts            use user scripts for dialing/hanging up instead of direct ioctl calls\n" );	
	fprintf( stderr, "   -path path             select directory with the up-/down-scripts\n\n" );
}

void printHeader()
{
	fprintf( stderr, "wmisdn v1.8 (C) 1999-2001 Tasho Statev Kaletha (kaletha@informatik.uni-bonn.de).\n\n" );
}

void parseDeviceNames( char *name_list )
{
	char *ptr1, *ptr2;
	int i;
	
	ptr1 = name_list;

	for( i = 0; i < ISDN_MAX_CHANNELS; i++ )
	{
		ptr2 = strchr(ptr1,',');
		if( ptr2 == NULL )
			ptr2 = &name_list[strlen(name_list)];
		strncpy( devices[i], ptr1, ptr2-ptr1 );
		devices[i][ptr2-ptr1] = 0;
		devices[i+1][0] = 0;		
		if( !validIppp(devices[i]) )
			fprintf( stderr, "Warning : \"%s\" doesn't seem to be a valid ippp device. wmisdn may not work properly\n", devices[i] );
		if( ptr2[0] == 0 )
			return;
		ptr1 = ptr2+1;
	}
}
	

bool scanArgs(int argc, char *argv[])
{
	bool dialmode_set = false;
	
	for(int i=1;i<argc;i++)
	{
		if(strcmp(argv[i],"-h")==0 || strcmp(argv[i],"-help")==0 || strcmp(argv[i],"--help")==0)
			return false;

		else if(strcmp(argv[i],"-w")==0)
			wmaker=true;
		else if(strcmp(argv[i],"-s")==0)
			ushape=true;
		else if(strcmp(argv[i],"-lamps")==0)
			lampsActive=true;
		else if(strcmp(argv[i],"-usescripts")==0)
			usescripts=true;

		else if(strcmp(argv[i],"-display")==0)
		{
			if(i<argc-1)
			{
				i++;
				if( strlen(argv[i]) > MAX_ARG_LEN-1 )
				{
					fprintf( stderr, "Argument for -display option too long\n" );
					return false;
				}
				sprintf(txtdpy,"%s",argv[i]);
			}
			continue;
		}
		else if(strcmp(argv[i],"-font")==0)
		{
			if(i<argc-1)
			{
				i++;
				if( strlen(argv[i]) > MAX_ARG_LEN-1 )
				{
					fprintf( stderr, "Argument for -font option too long\n" );
					return false;
				}
				sprintf(txtfont,"%s",argv[i]);
			}
			continue;
		}
		else if(strcmp(argv[i],"-dialmode")==0)
		{
			if(i<argc-1)
			{
				i++;
				if( strcmp(argv[i], "auto")==0 )
					dialmode = ISDN_NET_DM_AUTO;
				else if( strcmp(argv[i], "manual")==0 )
					dialmode = ISDN_NET_DM_MANUAL;
				else {
					fprintf( stderr, "Unknown dial mode \"%s\"\n", argv[i] ); 
					return false;
				}
				dialmode_set = true;
			}
		}
		else if(strcmp(argv[i],"-device")==0)
		{
			if(i<argc-1)
			{
				i++;
				if( strlen(argv[i]) > MAX_ARG_LEN-1 )
				{
					fprintf( stderr, "Argument for -device option too long\n" );
					return false;
				}
				parseDeviceNames( argv[i] );
				selected_device = 0;
			}
		}
		else if(strcmp(argv[i],"-path")==0)
		{
			if(i<argc-1)
			{
				i++;
				if( strlen(argv[i]) > MAX_ARG_LEN-1 )
				{
					fprintf( stderr, "Argument for -path option too long\n" );
					return false;
				}
				strcpy( scriptpath, argv[i] );
			}
		}
		else {
			fprintf( stderr, "Unknown option \"%s\"\n", argv[i] );
			return false;
		}
			
	}
	if( !dialmode_set )
		isdnInitDefaultDialmode();
	if( selected_device == -1 )
	{
		strcpy( devices[0], "ippp0" );
		devices[1][0] = 0;
		selected_device = 0;
	}
	
	return true;
}

/* Reads the string representations of the scriptmode parameter given to the up/down scripts
 * and initializes the coresponding variables */
void readScriptModes()
{
	char filename[1000];
	char buf[1000];
	sprintf( filename, "%s/%s", scriptpath, SCRIPT_MODES );
	FILE *f = fopen( filename, "r" );
	/* init one default string if reading fails */
	if( f == NULL || (fgets(buf,sizeof(buf),f) == NULL) || !usescripts )
	{
		maxscriptmode = 0;
		if( usescripts )
			syslog( LOG_NOTICE, "Couldn't read script mode strings: %m" );
		scriptmodestrings = (char **)malloc( sizeof(char*) );
		scriptmodestrings[0] = (char *)malloc( sizeof("go online") );
		strcpy(scriptmodestrings[0], "go online" );
		if( f != NULL ) 
			fclose(f);
		return;
	}
	maxscriptmode = -1; /* the first iteration sets it to 0 - first array index */

	/* read the strings and put them into the scriptmodestrings array */
	do
	{
		maxscriptmode++;
		scriptmodestrings = (char **)realloc( scriptmodestrings, (maxscriptmode+1)*sizeof(char*) );
		scriptmodestrings[maxscriptmode] = (char *)malloc( strlen(buf)+1 );
		while( strchr(buf,'\n') != NULL )
			*strchr(buf,'\n') = '\0';
		strcpy( scriptmodestrings[maxscriptmode], buf );
	} while( fgets(buf,sizeof(buf),f) != NULL );
	fclose(f);
}
		
void advanceScriptMode()
{
	scriptmode++;
	if(scriptmode > maxscriptmode)
		scriptmode = 0;
	update();
}

/* press event 
 * - if a lamp is pressed then the corresponding actions are taken.
 * - outside a lamp the extended view is turned on or off
 */
void pressEvent(XButtonEvent *xev)
{
	if( region_in( xev->window, xev->x, xev->y ) )
		region_mouse_click( xev->window, xev->x, xev->y, xev->button );
}

/* pointer motion
 * - draws a lamp in an active state if the pointer passes above it
 */
void motionEvent( XMotionEvent *xev )
{
	region_mouse_motion( xev->window, xev->x, xev->y );
}

void exposeEvent( XExposeEvent *xev )
{
	repaint( xev->window, xev->x, xev->y, xev->width, xev->height );
}

void alignInfoPanel()
{
	/* get the position of the main win */
	int win_x, win_y, screen_w, screen_h, panel_x, panel_y;
	getWindowPosition( Win[activeWin], &win_x, &win_y );
	getWindowDimension( Root, &screen_w, &screen_h );
	/* find a suitable position for the info panel */
	if( win_x - InfoWinDim.w > 0 )
		panel_x = win_x - InfoWinDim.w;
	else
		panel_x = win_x + MainWinDim.w;
	panel_y = win_y;
	/* move the panel */
	XMoveWindow( dpy, Win[2], panel_x, panel_y );
}

void mouseInLamp( int id )
{
	drawLamp( id, ACTIVE );
	for( int i=0; i < 3; i++ )
		repaint( Win[activeWin], LampsRect[i].pos.x, LampsRect[i].pos.y, LampsRect[i].dim.w, LampsRect[i].dim.h );
}

void mouseOutLamp( int id )
{
	drawLamp( id, INACTIVE );
	for( int i=0; i < 3; i++ )
		repaint( Win[activeWin], LampsRect[i].pos.x, LampsRect[i].pos.y, LampsRect[i].dim.w, LampsRect[i].dim.h );
}

void mouseClickLamp( int id, unsigned int button )
{
	pressLamp( id, button );
	update();
}

inline void drawInfoSwitch( int active )
{
	int pixmap_index = (infoPanelActive ? 2:0) + active;
	int offset_x = pixmap_index * InfoSWRect.dim.w;
	XCopyArea( dpy, infoSWPixmap, disp, WinGC, offset_x, 0, InfoSWRect.dim.w, InfoSWRect.dim.h, InfoSWRect.pos.x, InfoSWRect.pos.y );
	repaint( Win[activeWin], InfoSWRect.pos.x, InfoSWRect.pos.y, InfoSWRect.dim.w, InfoSWRect.dim.h );	
}

void mouseInInfoSw( int id )
{
	drawInfoSwitch(ACTIVE);
}

void mouseOutInfoSw( int id )
{
	drawInfoSwitch(INACTIVE);
}

void mouseClickInfoSw( int id, unsigned int button )
{
	if( !infoPanelActive )
	{
		alignInfoPanel();
		XMapWindow( dpy, Win[2] );
	} else
		XUnmapWindow( dpy, Win[2] );
	infoPanelActive = !infoPanelActive;
	mouseInInfoSw( ID_SWITCH_INFO );
	fullRepaint();
}

inline void drawLampsSwitch( int active )
{
	int pixmap_index = (lampsActive ? 2:0) + active;	
	int offset_x = pixmap_index * LampsSWRect.dim.w;
	XCopyArea( dpy, lampsSWPixmap, disp, WinGC, offset_x, 0, LampsSWRect.dim.w, LampsSWRect.dim.w, LampsSWRect.pos.x, LampsSWRect.pos.y );
	repaint( Win[activeWin], LampsSWRect.pos.x, LampsSWRect.pos.y, LampsSWRect.dim.w, LampsSWRect.dim.h );		
}

void mouseInLampsSw( int id )
{
	drawLampsSwitch(ACTIVE);
}

void mouseOutLampsSw( int id )
{
	drawLampsSwitch(INACTIVE);
}

void mouseClickLampsSw( int id, unsigned int button )
{
	activateLamps( !lampsActive );
	mouseInLampsSw( ID_SWITCH_LAMPS );
}

void activateLamps( bool active )
{
	if( active )
	{
		drawLamp( 0, INACTIVE );
		drawLamp( 1, INACTIVE );
		drawLamp( 2, INACTIVE );	
		region_enable( Win[activeWin], ID_LAMP_GREEN );
		region_enable( Win[activeWin], ID_LAMP_YELLOW );
		region_enable( Win[activeWin], ID_LAMP_RED );
	} else {
		for( int i=0; i < 3; i++ )
			blankMainWin( LampsRect[i].pos.x, LampsRect[i].pos.y, LampsRect[i].dim.w, LampsRect[i].dim.h );
		region_disable( Win[activeWin], ID_LAMP_GREEN );
		region_disable( Win[activeWin], ID_LAMP_YELLOW );
		region_disable( Win[activeWin], ID_LAMP_RED );
	}
	lampsActive = active;
	fullRepaint();
}

void drawSwitches()
{
	drawInfoSwitch( INACTIVE );
	drawLampsSwitch( INACTIVE );
}

void mouseInDevice( int id )
{
	drawDevice(ACTIVE);
	repaint( Win[activeWin], 0, 0, MainWinDim.w, MainWinDim.h );	
}

void mouseOutDevice( int id )
{
	drawDevice(INACTIVE);
	repaint( Win[activeWin], 0, 0, MainWinDim.w, MainWinDim.h );		
}

void mouseClickDevice( int id, unsigned int button )
{
	selectNextDevice();
	mouseInDevice( ID_DEVICE );
}


void drawDevice( int active )
{
	char *color = active == ACTIVE ? DeviceColorHigh : DeviceColorLow;
	drawText( devices[selected_device], disp, DeviceRect.pos.x, DeviceRect.pos.y, color );
}

void mouseInStatusSw( int id )
{
       /* drawStatusSw( ACTIVE ); */
}

void mouseOutStatusSw( int id )
{
       /* drawStatusSw( INACTIVE ); */
}

void mouseClickStatusSw( int id, unsigned int button )
{
       if(button == 2)
               pressStatusSw();
}

/* void drawStatusSw( int active ) */

void getWindowPosition( Window win, int *x, int *y )
{
	XWindowAttributes winAttr;
	Window dummy;
	
	XGetWindowAttributes( dpy, win, &winAttr );
	XTranslateCoordinates( dpy, win, winAttr.root, 
						  -winAttr.border_width, -winAttr.border_width, 
						  x, y, &dummy );
}

void getWindowDimension( Window win, int *w, int *h )
{
	XWindowAttributes winAttr;
	XGetWindowAttributes( dpy, win, &winAttr );	
	*w = winAttr.width;
	*h = winAttr.height;
}
void repaint( Window win, int x, int y, int w, int h )
{
	//bad code start
	Pixmap src;
	if( win == Win[activeWin] )
		src = disp;
	else if( win == Win[2] )
		src = disp_info;
	else {
		syslog( LOG_DEBUG, "Oops! Unknown window given to repaint\n" ); 
		return;
	}
	//bade code end
	
	XCopyArea( dpy, src, win, WinGC, x, y, w, h, x, y );
	XFlush(dpy);
}

void fullRepaint()
{
	repaint( Win[activeWin], 0, 0, MainWinDim.w, MainWinDim.h );
	if( infoPanelActive )
		repaint( Win[2], 0, 0, InfoWinDim.w, InfoWinDim.h );
}

bool timeToUpdate()
{
	static int ticker = 0;
	if( ticker++ > UPDATE_INTERVAL )
	{
		ticker = 0;
		return true;
	}
	return false;
}

/* get ISDN device status and update windows as needed */
void update()
{
	isdnStatus stat;
	getStatus( devices[selected_device], &stat );
	if( memcmp(&curStatus, &stat, sizeof(stat)) != 0 )
	{
		memcpy( &curStatus, &stat, sizeof(stat) );
		setStatusPixmap();
//		drawDevice();
		repaint( Win[activeWin], 0, 0, MainWinDim.w, MainWinDim.h );
	}
	updateInfoPanel();
	repaint( Win[2], 0, 0, InfoWinDim.w, InfoWinDim.h );			
}

/* set the appropriate pixmap on the main window */	
void setStatusPixmap()
{
	Pixmap statusPixmap, directionPixmap;
	
	if( curStatus.usage > ISDN_USAGE_NONE && curStatus.usage <= ISDN_USAGE_FAX )
	{
		statusPixmap = statusPixmaps[curStatus.usage];
		switch( curStatus.mpppMode )
		{
			case slave	: directionPixmap = slavePixmap; break;
			case master	: 	if( curStatus.bundled == true ) { directionPixmap = bundledPixmap; break; }
							if( is_slave_pending() ) { directionPixmap = bundlingPixmap; break; }
			case none	: directionPixmap = curStatus.direction == INCOMING ? incomingPixmap : outgoingPixmap; break;
			default : syslog( LOG_DEBUG, "Ooops! curStatus.direction has an invalid value\n" ); directionPixmap = 0;
		}
	}
	else {
		switch( curStatus.usage ) 
		{
			case STAT_OFF 		: statusPixmap = offPixmap; break;
			case ISDN_USAGE_NONE: statusPixmap = statusPixmaps[ISDN_USAGE_NONE]; break;			
			case STAT_DISABLED 	: statusPixmap = disabledPixmap; break;
			case STAT_DIALING	: statusPixmap = dialingPixmap; break;
			case STAT_UNKNOWN	: statusPixmap = unknownPixmap; break; 
			default : syslog( LOG_DEBUG, "Ooops! curStatus.usage has an invalid value\n" ); statusPixmap = 0;
		}
		directionPixmap = 0;
	}
	if( statusPixmap != 0 )
		XCopyArea(dpy, statusPixmap, disp, WinGC, StatusPixmapRect.pos.x, StatusPixmapRect.pos.y, StatusPixmapRect.dim.w, StatusPixmapRect.dim.h, StatusPixmapRect.pos.x, StatusPixmapRect.pos.y);
	if( directionPixmap != 0 )
		XCopyArea(dpy, directionPixmap, disp, WinGC, DirectionPixmapRect.pos.x, DirectionPixmapRect.pos.y, DirectionPixmapRect.dim.w, DirectionPixmapRect.dim.h, DirectionPixmapRect.pos.x, DirectionPixmapRect.pos.y);	
}
	
/* update the info panel */
void updateInfoPanel()
{
	XSetForeground( dpy, WinGC, getColor(WindowBackgroundColor) );
	XFillRectangle( dpy, disp_info, WinGC, 0, 0, InfoWinDim.w, InfoWinDim.h );
	char line[100];
	if( (curStatus.usage > ISDN_USAGE_NONE && curStatus.usage <= ISDN_USAGE_FAX) || curStatus.usage == STAT_DIALING )
	{
		sprintf( line, "peer phone: %s", curStatus.peerPhone );
		drawText( line, disp_info, 5, 5 );
	}
	if( (curStatus.usage == ISDN_USAGE_NET) && (curStatus.mpppMode != slave) )
	{
		int a, b, c, d;
		getLocalIP( &a, &b, &c, &d );
		sprintf( line, "local ip : %d.%d.%d.%d", a, b, c, d );
		drawText( line, disp_info, 5, 20 );
		getRemoteIP( &a, &b, &c, &d );
		sprintf( line, "remote ip: %d.%d.%d.%d", a, b, c, d );
		drawText( line, disp_info, 5, 35 );
	} 
	else if( curStatus.usage == STAT_OFF )
			drawText( "dialing disabled", disp_info, 5, 5 );
	else if( curStatus.usage == STAT_DISABLED )
		drawText( "device disabled", disp_info, 5, 5 );	
	else if( curStatus.usage == ISDN_USAGE_NONE )
	{
		drawText( "not connected", disp_info, 5, 5 );
		sprintf( line, "action: %s", scriptmodestrings[scriptmode] );
		drawText( line, disp_info, 5, 20 );
	}
	switch( curStatus.mpppMode )
	{
		case none : sprintf( line, "bundling: none" ); break;
		case master : sprintf( line, "bundling: master of %s", curStatus.mpppPartner ); break;
		case slave : sprintf( line, "bundling: slave of %s", curStatus.mpppPartner ); break;
	}
	drawText( line, disp_info, 5, 50 );
}

void blankMainWin( int x, int y, int w, int h )
{
	XCopyArea(dpy, coverPixmap, disp, WinGC, x, y, w, h, x, y);
}

unsigned long getColor( const char *colorname )
{
	XColor color;
	XWindowAttributes winattr;
	XGetWindowAttributes(dpy, Root, &winattr);
	color.pixel=0;
	XParseColor(dpy, winattr.colormap, colorname, &color);
	color.flags=DoRed | DoGreen | DoBlue;
	XAllocColor(dpy, winattr.colormap, &color);
	return color.pixel;
}      

void createPixmap(char *data[], Pixmap *image, Pixmap *mask )
{
	XpmAttributes pixatt;
	
	pixatt.exactColors=false;
	pixatt.closeness=40000;
	pixatt.valuemask=XpmExactColors | XpmCloseness | XpmSize;
	XpmCreatePixmapFromData(dpy, Root, data, image, mask, &pixatt);
}

void loadLeds( char *data[], Pixmap *image, const char *led_color, const char *back_color)
{
	XpmAttributes pixatt;
	unsigned long color[4];
	
	color[0] = mixColor(led_color, 0, back_color, 100);
	color[1] = mixColor(led_color, 100, back_color, 0);
	color[2] = mixColor(led_color, 60, back_color, 40);
	color[3] = mixColor(led_color, 25, back_color, 75);
	
	XpmColorSymbol xpmcsym[4]={{"led_color_back",     NULL, color[0] },
	                           {"led_color_high", NULL, color[1]},
	                           {"led_color_med",  NULL, color[2]},
	                           {"led_color_low",  NULL, color[3]}};
	
	
	pixatt.numsymbols = 4;
	pixatt.colorsymbols = xpmcsym;
	pixatt.exactColors = false;
	pixatt.closeness = 40000;
	pixatt.valuemask = XpmColorSymbols | XpmExactColors | XpmCloseness | XpmSize;
	XpmCreatePixmapFromData(dpy, Root, data, image, NULL, &pixatt);
}

unsigned long mixColor( const char *colorname1, int prop1, const char *colorname2, int prop2 )
{
	XColor color, color1, color2;
	XWindowAttributes winattr;
	XGetWindowAttributes(dpy, Root, &winattr);
	XParseColor(dpy, winattr.colormap, colorname1, &color1);
	XParseColor(dpy, winattr.colormap, colorname2, &color2);
	color.pixel=0;
	color.red=(color1.red*prop1+color2.red*prop2)/(prop1+prop2);
	color.green=(color1.green*prop1+color2.green*prop2)/(prop1+prop2);
	color.blue=(color1.blue*prop1+color2.blue*prop2)/(prop1+prop2);
	color.flags=DoRed | DoGreen | DoBlue;
	XAllocColor(dpy, winattr.colormap, &color);
	return color.pixel;
}

/* draws text on dst using the led symbols from the leds pixmap */
void leds_drawText( char *text, Pixmap dst, int x, int y, const char *color )
{
	Pixmap leds_pixmap;
	loadLeds( leds_xpm, &leds_pixmap, color, WindowBackgroundColor );

	x -= 3;
	char *led_ptr;
	while( *text != 0 )
	{
		led_ptr = strchr( led_text, tolower(*text) );
		if( led_ptr == NULL )
		{
			/*syslog( LOG_DEBUG, "Oops! Internal bug in drawText: No led symbol for char %c\n", *text );*/
			led_ptr = strchr( led_text, '?' );
		}
		XCopyArea( dpy, leds_pixmap, dst, WinGC, (led_ptr-led_text)*LedDim.w, 0, LedDim.w, LedDim.h, x, y );
		x += LedDim.w;
		text++;
	}
	XFreePixmap( dpy, leds_pixmap );
}

/* draws text on dst using the X-Font from textFont */
void font_drawText( char *text, Pixmap dst, int x, int y, const char *color )
{
	XSetForeground( dpy, WinGC, getColor(color) );
	XDrawImageString( dpy, dst, WinGC, x, y+textFont->ascent/2, text, strlen(text) );
}

void drawText( char *text, Pixmap dst, int x, int y, const char *color )
{
	if( textFont == NULL )
		leds_drawText( text, dst, x, y, color );
	else
		font_drawText( text, dst, x, y, color );
}

/* draws the lamp in the specified state */
void drawLamp( int lamp, int active )
{
	int disp_x, disp_y, lamp_x=0;
	
	disp_x = LampsRect[lamp].pos.x;
	disp_y = LampsRect[lamp].pos.y;
	
	/* find the offset of the lamp pixmap in the pixmap of all lamps */
	for( int i=0; i < lamp; i++ )
		lamp_x += LampsRect[i].dim.w*2;
	lamp_x += active*LampsRect[lamp].dim.w;		
	
	XCopyArea( dpy, lampsPixmap, disp, WinGC, lamp_x, 0, LampsRect[lamp].dim.w, LampsRect[lamp].dim.h, disp_x, disp_y );
}

void isdnInitDefaultDialmode()
{
	seteuid( rootUID );
	setegid( rootGID );

	isdn_net_ioctl_cfg cfg;
	strcpy( cfg.name, devices[selected_device] );
	if( isdn_ioctl( IIOCNETGCF, &cfg, NULL ) != -1 )
		dialmode = cfg.dialmode;
	else
		dialmode = ISDN_NET_DM_AUTO;  /* for the sake of cleanness, we'll get an error msg soon anyway */
	if( dialmode == ISDN_NET_DM_OFF ) 
		dialmode = ISDN_NET_DM_AUTO;  /* use auto as default dialmode if device disabled */

	seteuid( getuid() );
	setegid( getgid() );
}

int isdn_ioctl( int func, void *arg, const char *errmsg, const char *filename )
{
	int fd = fd = open( filename, O_RDONLY );
	if( fd == -1 )
	{
		if( errmsg != NULL )
			syslog( LOG_NOTICE, "Couldn't open %s : %m\n", filename );
		return -1;
	}
	
	int res = ioctl( fd, func, arg );
	if( res == -1 && errmsg != NULL )
		syslog( LOG_NOTICE, "%s : %m\n", errmsg ); 

	close(fd);
	
	return res;
}

inline void isdn_dial()
{
	if( !usescripts )
		isdn_ioctl( IIOCNETDIL, devices[selected_device], "Couldn't dial" );
	else 
	{
	
		int handle;
		char command[MAX_ARG_LEN];
		
		strcpy(command, scriptpath);
		strcat(command, "/");
		strcat(command, SCRIPT_UP);
		if ((handle = open(command, O_RDONLY)) == -1)
			syslog( LOG_NOTICE, "Couldn't open %s : %m\n", SCRIPT_UP );
		else {
			close(handle);
			sprintf(command, "%s/%s %s %d 2>&1 | logger -t wmisdn.sh &", scriptpath, SCRIPT_UP, devices[selected_device], scriptmode);
			system(command);
		}
	}
	update();	
}

inline void isdn_hangup()
{
	if( !usescripts )
		isdn_ioctl( IIOCNETHUP, devices[selected_device], "Couldn't hang up" );
	else 
	{
		int handle;
		char command[MAX_ARG_LEN];
		
		strcpy(command, scriptpath);
		strcat(command, "/");
		strcat(command, SCRIPT_DOWN);
		
		if ((handle = open(command, O_RDONLY)) == -1)
			syslog( LOG_NOTICE, "Couldn't open %s : %m\n", SCRIPT_DOWN );
		else {
			close(handle);
			sprintf(command, "%s/%s %s %d 2>&1 | logger -t wmisdn.sh &", scriptpath, SCRIPT_DOWN, devices[selected_device], scriptmode);
			system(command);
		}
	}
	update();
}

inline void isdn_enable()
{
	isdn_net_ioctl_cfg cfg;
	strcpy( cfg.name, devices[selected_device] );
	if( isdn_ioctl( IIOCNETGCF, &cfg, "Error enabling dialing. Couldn't get dev cfg" ) != -1 )
	{
		cfg.dialmode = dialmode;
		isdn_ioctl( IIOCNETSCF, &cfg, "Error enabling dialing. Couldn't set dev cfg" );
	}
}

inline void isdn_disable()
{
	isdn_net_ioctl_cfg cfg;
	strcpy( cfg.name, devices[selected_device] );
	if( isdn_ioctl( IIOCNETGCF, &cfg, "Error disabling dialing. Couldn't get dev cfg" ) != -1 )
	{
		cfg.dialmode = ISDN_NET_DM_OFF;
		isdn_ioctl( IIOCNETSCF, &cfg, "Error disabling dialing. Couldn't set dev cfg" );
	}
}

inline void isdn_dial_slave( char *master )
{
	isdn_ioctl( IIOCNETALN, master, "Couldn't fire up slave" );
}

inline void isdn_hangup_slave( char *master )
{
	isdn_ioctl( IIOCNETDLN, master, "Couldn't hang up slave" );
}

inline void set_slave_pending()
{
	slave_pending = devices[selected_device];
}

inline void clear_slave_pending()
{
	slave_pending = NULL;
}

inline bool is_slave_pending()
{
	return slave_pending != NULL;
}

inline void manage_slave()
{
	if( is_slave_pending() )
	{
		if( curStatus.usage == ISDN_USAGE_NET )
		{
			isdn_dial_slave(slave_pending);
			clear_slave_pending();
		}
		if( curStatus.usage == ISDN_USAGE_NONE )
			clear_slave_pending();
	}
}

/* react upon a lamp press 
 * - green opens a connection and sets the device in dial_auto mode
 * - yellow ends the connection and sets the device in dial_auto mode
 * - red ends the connection and sets the device in dial_off mode
 */

inline void _pressGreenLamp( int button )
{
	/* middle button - just change the script mode */
	if( button == 2 ) 
	{
		advanceScriptMode(); 
		return;
	}
	/* online request of slave - add a channel to the master */
	if( curStatus.mpppMode == slave )
		isdn_dial_slave( curStatus.mpppPartner );
	/* online request of master or non-bundled device */
	else {
		/* additional mppp-link requested - add a slave channel to the master (wait until master online) */
		if( (button == 3) && (curStatus.mpppMode == master) )
			set_slave_pending();
		/* if device is dialing or online - ignore button */
		if( curStatus.usage == STAT_DIALING || curStatus.usage == ISDN_USAGE_NET )
			return;
		if( curStatus.usage == STAT_OFF ) 
			isdn_enable(); 
		isdn_dial(); 
	}
}

inline void _pressYellowLamp( int button )
{
	if( curStatus.usage == ISDN_USAGE_NONE ) 
		return;
	if( curStatus.usage == STAT_OFF )
		isdn_enable();			
	else 
	{
		if( (button == 3) || (button == 1) && (curStatus.mpppMode == master) )
			isdn_hangup_slave( devices[selected_device] );
		if( button == 1 )
		{
			if( curStatus.mpppMode == slave )
				isdn_hangup_slave( curStatus.mpppPartner );
			else
				isdn_hangup();
		}
	}
}

inline void _pressRedLamp( int button )
{
	if( (curStatus.usage == STAT_OFF) || (button != 1) ) 
		return;
	_pressYellowLamp( button );
	isdn_disable(); 
}

void pressLamp( int lamp_id, int button )
{
	seteuid( rootUID );
	setegid( rootGID );
	switch( lamp_id )
	{
		case ID_LAMP_GREEN	: _pressGreenLamp( button );break;
		case ID_LAMP_YELLOW	: _pressYellowLamp( button ); break;
		case ID_LAMP_RED	: _pressRedLamp( button ); break;
	}
	seteuid( getuid() );
	setegid( getgid() );
}

/* activated when user clicks the status pixmap with the right button - switch online<->offline */
void pressStatusSw()
{
	seteuid( rootUID );
	setegid( rootGID );
	
	if( curStatus.usage == ISDN_USAGE_NONE )
		_pressGreenLamp(1);
	else if(curStatus.usage == ISDN_USAGE_NET )
		_pressYellowLamp(1);

	seteuid( getuid() );
	setegid( getgid() );
}


/* Get the local/remote IP addresses of the devices[selected_device] */

void getLocalIP( int *a, int *b, int *c, int *d )
{
	struct ifreq ifr;
	int fd = socket( AF_INET, SOCK_DGRAM, 0 );

	strcpy( ifr.ifr_ifrn.ifrn_name, devices[selected_device] );
	ifr.ifr_ifru.ifru_addr.sa_family = AF_INET;
	int res = ioctl(fd, SIOCGIFADDR, &ifr);
	close(fd);
	translateIP( &(ifr.ifr_ifru.ifru_addr), a, b, c, d );
	
	if( res != 0 )
		syslog( LOG_NOTICE, "Oops! Couldn't get local IP of device %s. ioctl() call failed : %m\n", devices[selected_device] );
}

void getRemoteIP( int *a, int *b, int *c, int *d )
{
	struct ifreq ifr;
	int fd = socket( AF_INET, SOCK_DGRAM, 0 );
	
	strcpy( ifr.ifr_ifrn.ifrn_name, devices[selected_device] );
	ifr.ifr_ifru.ifru_addr.sa_family = AF_INET;
	int res = ioctl( fd, SIOCGIFDSTADDR, &ifr );
	close(fd);
	translateIP( &(ifr.ifr_ifru.ifru_addr), a, b, c, d );

	if( res != 0 )
		syslog( LOG_NOTICE, "Oops! Couldn't get remote IP of device %s. ioctl() call failed : %m\n", devices[selected_device]);
}

/* extract the ip address from the addr struct asuming that it is a valid INET sockaddr */
inline void translateIP( struct sockaddr *addr, int *a, int *b, int *c, int *d )
{
	struct sockaddr_in* inet_addr = (sockaddr_in *)addr;
	unsigned int ip = inet_addr->sin_addr.s_addr;
	*d = (ip >> 24) & 0xFF;
	*c = (ip >> 16) & 0xFF;
	*b = (ip >> 8 ) & 0xFF;
	*a = ip & 0xFF;
}

/* extract the data from the 'key'-line of /dev/isdninfo for all 16 B-Channels */
bool extractIsdnInfoData( const char *all_data, const char *key, char buffer[ISDN_MAX_CHANNELS][100] )
{
	char temp[100]; /* buffer the key string */
	char *ptr;
	
	ptr = strstr( all_data, key );
	if( ptr == NULL )
	{
		syslog( LOG_NOTICE, "Error getting status info. /dev/isdninfo doesn't contain a '%s' line\n", key );
		return false;
	}
	sscanf( ptr, "%s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s %s",
		   temp,
		   buffer[0], buffer[1], buffer[2], buffer[3],
		   buffer[4], buffer[5], buffer[6], buffer[7],
		   buffer[8], buffer[9], buffer[10], buffer[11],
		   buffer[12], buffer[13], buffer[14], buffer[15] );

	return true;
}

bool getPeerPhone( char *ippp, char *phone )
{
	isdn_net_ioctl_phone ippp_phone;
	int res;
	
	strcpy( ippp_phone.name, ippp );
	res = isdn_ioctl( IIOCNETGPN, &ippp_phone, NULL, "/dev/isdninfo" );
	if( res < 0 )
	{
		if( errno != ENOTCONN ) /* device not connected - no real error */
			syslog( LOG_NOTICE, "Error getting phone number for device %s: %m", ippp );
		return false;
	}
	strcpy( phone, ippp_phone.phone );
	return true;
}

bool findBChannel( char *phone, char all_phones[ISDN_MAX_CHANNELS][100], int &channel )
{
	for( int i=0; i < ISDN_MAX_CHANNELS; i++ )
		if( strcmp( all_phones[i], phone ) == 0 )
		{
			channel = i;
			return true;
		}
	syslog( LOG_NOTICE, "Hmm!!?? That's strange! Device phone number %s couldn't be found in /dev/isdninfo", phone );
	return false;
}

void getMPPPSettings( isdn_net_ioctl_cfg *cfg, isdnStatus *stat )
{
	stat->mpppMode = none;	
	if( strlen(cfg->master) != 0 )
	{
		stat->mpppMode = slave;
		strcpy( stat->mpppPartner, cfg->master );
	}
	if( strlen(cfg->slave) != 0 )
	{
		stat->mpppMode = master;
		strcpy( stat->mpppPartner, cfg->slave );
	}
}
	
/* get the status of the ippp device: 
 * 
 * - isOff if dialing is disabled
 * - isOffline if dialing is enabled but no connection is established
 * - isOnline if device has established a connection
 * - isDialing if device is dialing the remote but no connection is established
 * - isUnknown if no stat info available 
 */
void getStatus( char *device, isdnStatus *stat )
{
	isdn_net_ioctl_cfg cfg;
	int fd, len, res;
	char buf[10000];
	static int warning_count=0;
	int channel, channel_usage;
	char channel_info[ISDN_MAX_CHANNELS][100];


	/* get ippp device config */
	seteuid( rootUID );
	setegid( rootGID );
	strcpy( cfg.name, device );
	res = isdn_ioctl( IIOCNETGCF, &cfg, warning_count < STATUS_WARNING_SAT ? "Error getting status info. Couldn't get device cfg" : (char *)NULL );
	seteuid( getuid() );
	setegid( getgid() );

	stat->usage = STAT_UNKNOWN;
	stat->direction = INCOMING;
	
	if( res == -1 )
	{
		warning_count++;
		return;
	}
	warning_count = 0;
	if( cfg.dialmode == ISDN_NET_DM_OFF  )
		stat->usage = STAT_OFF;
	else
		stat->usage = ISDN_USAGE_NONE;

	stat->bundled = false;
	getMPPPSettings( &cfg, stat );	
	
	/* read the device flags from /dev/isdninfo */
	fd = open( "/dev/isdninfo", O_RDONLY|O_NDELAY );
	if( fd == -1 )
	{
		syslog( LOG_NOTICE, "Error getting status info. Couldn't open /dev/isdninfo : %m\n" );
		return;
	}
	len = read( fd, buf, sizeof(buf)-1 );
	close(fd);
	if( len == -1 )
	{
		syslog( LOG_NOTICE, "Error getting status info. Couldn't read from /dev/isdninfo : %m\n" );
		return;
	}
	buf[len] = 0; 						/* terminate the string */

	if( !extractIsdnInfoData( buf, "phone:", channel_info ) )
		return;
	if( !getPeerPhone( device, stat->peerPhone ) )
		return;
	if( !findBChannel( stat->peerPhone, channel_info, channel ) )
		return;
	if( !extractIsdnInfoData( buf, "usage:", channel_info ) )
		return;
	
	channel_usage = atoi(channel_info[channel]);
	if( (channel_usage & ISDN_USAGE_DISABLED) != 0 )
		stat->usage = STAT_DISABLED;
	else
		stat->usage =  channel_usage & ISDN_USAGE_MASK;
	stat->direction = (channel_usage & ISDN_USAGE_OUTGOING) == 0 ? INCOMING : OUTGOING;
	
	/* check if device is still dialing or already online */
	if( stat->usage == ISDN_USAGE_NET )
	{
		
		if( !extractIsdnInfoData( buf, "flags:", channel_info ) )
			return;
	
		if( ((atoi(channel_info[0]) >> channel) & 1) == 0 )
			stat->usage = STAT_DIALING;
	}
	/* check for channel bundling */
	if( stat->mpppMode == master )
	{
		isdnStatus slaveStatus;
		getStatus( stat->mpppPartner, &slaveStatus );
		if( (stat->usage == slaveStatus.usage) && (stat->direction == slaveStatus.direction) && 
			(strcmp(stat->peerPhone,slaveStatus.peerPhone)==0) )
			stat->bundled = true;
	} 
}