workbench/devs/networks/ppp/ModemManager/ModemManager.c

   1 /*
   2  * $Id$
   3  */
   4
   5 #define DEBUG 1
   6 #include <exec/types.h>
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <math.h>
  11 #include <dos/dos.h>
  12 #include <intuition/gadgetclass.h>
  13 #include <intuition/icclass.h>
  14 #include <proto/exec.h>
  15 #include <proto/intuition.h>
  16 #include <proto/muimaster.h>
  17 #include <proto/dos.h>
  18 #include <proto/graphics.h>
  19 #include <clib/alib_protos.h>
  20 #include <proto/muimaster.h>
  21 #include <proto/miami.h>
  22 #include <utility/hooks.h>
  23 #include <libraries/mui.h>
  24 #include <aros/debug.h>
  25 #include <sys/socket.h>
  26 #include <netinet/in.h>
  27
  28 #include "ppp.h"
  29 #include "misc.h"
  30
  31 #define SimpleText(text) TextObject, MUIA_Text_Contents, (IPTR) text, End
  32
  33 #define TIMERVALUE 5
  34 #define STRSIZE 100
  35
  36 #define STATE_UNPLUGGED 0
  37 #define STATE_PLUGGED 1
  38 #define STATE_OPENDEV 2
  39 #define STATE_NETWORK 3
  40 #define STATE_CLOSEDEV 4
  41
  42 Object *application=0,*window,*DisConBut,*ConBut;
  43 Object *ModemName,*AccessType;
  44 Object *IN_Info,*OUT_Info;
  45
  46 struct EasyBitmap *SignalBM=0;
  47
  48 UBYTE *PortName = "ModemManager";
  49 const TEXT version_string[] = "$VER: ModemManager 1.2 (1.3.2012)";
  50
  51 ULONG exPhase,exstate;
  52 BOOL exSer;
  53
  54 struct EasyBitmap{
  55         struct BitMap *bm;
  56         struct RastPort *rp;
  57         Object *MUIbitmap;
  58 };
  59
  60 struct EasyBitmap *MakeBitmap(ULONG x,ULONG y,Object *MUIwindow,Object *MUIbitmap){
  61         struct EasyBitmap *ebm=NULL;
  62         struct Window *tw=NULL;
  63
  64         if( MUIwindow && MUIbitmap ){
  65                 if( ebm = AllocMem( sizeof(struct EasyBitmap),MEMF_CLEAR|MEMF_PUBLIC)){
  66
  67                         tw=(struct Window *)XGET( MUIwindow , MUIA_Window_Window );
  68
  69                         ebm->bm = AllocBitMap(x,y,
  70                                          GetBitMapAttr(tw->RPort->BitMap, BMA_DEPTH),
  71                                          BMF_CLEAR,
  72                                          tw->RPort->BitMap);
  73                         ebm->rp = CreateRastPort();
  74                         ebm->rp->BitMap = ebm->bm;
  75                         ebm->MUIbitmap = MUIbitmap;
  76                         set( MUIbitmap , MUIA_FixWidth, x );
  77                         set( MUIbitmap , MUIA_FixHeight, y );
  78                         set( MUIbitmap , MUIA_Bitmap_Width, x );
  79                         set( MUIbitmap , MUIA_Bitmap_Height, y );
  80                         set( MUIbitmap , MUIA_Bitmap_Transparent, 0 );
  81                         set( MUIbitmap , MUIA_Bitmap_Bitmap, ebm->bm );
  82                         DoMethod( MUIbitmap , MUIM_Draw);
  83                 }
  84         }
  85         return ebm;
  86 }
  87
  88 void _CloseBitmap(struct EasyBitmap *ebm){
  89         if(ebm){
  90                 FreeRastPort(ebm->rp);
  91                 FreeBitMap(ebm->bm);
  92                 FreeMem(ebm,sizeof(struct EasyBitmap));
  93         }
  94 }
  95 #define CloseBitmap( ebm ) do{_CloseBitmap(ebm);ebm=NULL;}while(0)
  96
  97
  98 struct EasyGraph{
  99         struct EasyBitmap *ebm;
 100         ULONG Xsize,Ysize;
 101         FLOAT Max;
 102         FLOAT *value;
 103 };
 104
 105 void _CloseGraph(struct EasyGraph *egr){
 106         if(egr){
 107                 CloseBitmap( egr->ebm );
 108                 if( egr->value ) FreeMem( egr->value , sizeof(FLOAT) * egr->Xsize );
 109                 FreeMem(egr,sizeof(struct EasyGraph));
 110         }
 111 }
 112 #define CloseGraph( x ) do{_CloseGraph(x);x=NULL;}while(0)
 113
 114 struct EasyGraph *MakeGraph(ULONG x,ULONG y,Object *MUIwindow,Object *MUIbitmap){
 115         struct EasyGraph *egr=NULL;
 116         if( MUIwindow && MUIbitmap ){
 117                 if( egr = AllocMem( sizeof(struct EasyGraph),MEMF_CLEAR|MEMF_PUBLIC)){
 118                         egr->Xsize = x;
 119                         egr->Ysize = y;
 120                         egr->Max = 0.0;
 121                         if( egr->value = AllocMem( sizeof(FLOAT) * x ,MEMF_CLEAR|MEMF_PUBLIC)){
 122                                 if( egr->ebm = MakeBitmap(x,y,MUIwindow,MUIbitmap) ){
 123                                         SetRast(egr->ebm->rp,0);
 124                                         DoMethod( egr->ebm->MUIbitmap , MUIM_Draw );
 125                                 }else CloseGraph(egr);
 126                         }
 127                 }
 128         }
 129         return egr;
 130 }
 131
 132 void UpdateGraph(struct EasyGraph *egr,FLOAT value){
 133         LONG i;
 134         LONG h;
 135         if(egr){
 136
 137                 for( i= egr->Xsize-1 ; i > 0 ; i-- ){
 138                         egr->value[i] = egr->value[i-1];
 139                 }
 140
 141                 egr->value[0] = value;
 142                 if( value > egr->Max ) egr->Max = value;
 143
 144                 if( egr->ebm ){
 145
 146                         SetRast(egr->ebm->rp,0);
 147                         SetAPen(egr->ebm->rp,1);
 148                         Move(egr->ebm->rp , 0 , egr->Ysize-1 );
 149                         Draw(egr->ebm->rp , egr->Xsize-1 , egr->Ysize-1 );
 150                         SetAPen(egr->ebm->rp,2);
 151
 152                         if( egr->Max != 0.0 ){
 153                                 for( i=0 ; i < egr->Xsize ; i++ ){
 154                                         h = (LONG)( egr->value[i] / egr->Max * (FLOAT)( egr->Ysize - 2 ) );
 155                                         if(i==0) Move(egr->ebm->rp , i , (egr->Ysize-2) - h );
 156                                                 else Draw(egr->ebm->rp , i , (egr->Ysize-2) - h );
 157                                 }
 158                         }else{
 159                                 Move(egr->ebm->rp , 0 , egr->Ysize-2 );
 160                                 Draw(egr->ebm->rp , egr->Xsize-1 , egr->Ysize-2 );
 161                         }
 162
 163                         DoMethod( egr->ebm->MUIbitmap , MUIM_Draw );
 164
 165                 }
 166         }
 167 }
 168
 169
 170 BOOL SafePutToPort(struct PPPcontrolMsg *message, STRPTR portname)
 171 {
 172         struct MsgPort *port;
 173         Forbid();
 174                 port = FindPort(portname);
 175                 if (port){
 176                         struct Message *M;
 177                         ForeachNode(&port->mp_MsgList,M){
 178                                 if( (APTR)message == (APTR)M ){
 179                                         //      bug("SafePutToPort: message is already here !\n");
 180                                         Permit();
 181                                         return FALSE;
 182                                 };
 183                         }
 184                         PutMsg(port,(struct Message *)message);
 185                 }
 186         Permit();
 187         return(port ? TRUE : FALSE);
 188 }
 189
 190 BOOL SendCtrlMsg(ULONG command,IPTR Arg,struct Conf *c){
 191         struct PPPcontrolMsg *CtrlMsg=0;
 192         struct MsgPort *CtrlPort=0;
 193         BOOL succes=FALSE;
 194         if( CtrlPort = CreatePort(0,0) ){
 195                 if( CtrlMsg = AllocMem(sizeof(struct PPPcontrolMsg),MEMF_PUBLIC | MEMF_CLEAR)){
 196
 197                         CtrlMsg->Command = command;
 198                         CtrlMsg->Arg = Arg;
 199
 200                         CtrlMsg->DeviceName = c->DeviceName;
 201                         CtrlMsg->UnitNum = c->SerUnitNum;
 202                         CtrlMsg->username = c->username;
 203                         CtrlMsg->password = c->password;
 204
 205                         CtrlMsg->Msg.mn_Node.ln_Type = NT_MESSAGE;
 206                         CtrlMsg->Msg.mn_Length = sizeof(struct PPPcontrolMsg);
 207                         CtrlMsg->Msg.mn_ReplyPort = CtrlPort;
 208                         if( SafePutToPort(CtrlMsg, "ppp-control") ){
 209                                 WaitPort(CtrlPort);
 210                                 GetMsg(CtrlPort);
 211                                 succes=TRUE;
 212                         }
 213                         FreeMem(CtrlMsg,sizeof(struct PPPcontrolMsg));
 214                 }
 215                 DeletePort(CtrlPort);
 216         }
 217         return succes;
 218 }
 219
 220 BOOL SendRequest(void){
 221         struct PPPcontrolMsg *CtrlMsg;
 222         BOOL result=FALSE;
 223
 224         if( CtrlMsg = AllocMem(sizeof(struct PPPcontrolMsg),MEMF_PUBLIC | MEMF_CLEAR)){
 225                 bug("ModemManager:send info request\n");
 226                 CtrlMsg->Command = PPP_CTRL_INFO_REQUEST;
 227                 CtrlMsg->Arg = (IPTR)PortName;
 228                 CtrlMsg->Msg.mn_Node.ln_Type = NT_MESSAGE;
 229                 CtrlMsg->Msg.mn_Length = sizeof(struct PPPcontrolMsg);
 230                 CtrlMsg->Msg.mn_ReplyPort = 0;
 231                 if( SafePutToPort(CtrlMsg, "ppp-control") ) result=TRUE;
 232                 FreeMem(CtrlMsg , sizeof(struct PPPcontrolMsg));
 233         }
 234         return result;
 235 }
 236
 237
 238 void speedstr(BYTE *buf,BYTE *label,LONG s){
 239         float speed= (float)s;
 240         BYTE e = 'b';
 241         if( speed > 1000.0 ){
 242                 e = 'k';
 243                 speed /= 1000.0;
 244         }
 245         if( speed > 1000.0 ){
 246                  e = 'M';
 247                  speed /= 1000.0;
 248         }
 249         snprintf( buf, STRSIZE , speed == (ULONG)speed ? "%s %.0f %c/s" :"%s %.2f %c/s" , label , speed , e );
 250 }
 251
 252 // draw triangular signal meter and show modem name etc..
 253 void UpdateModemInfo(struct EasyBitmap *ebm,struct Conf *c)
 254 {
 255         ULONG i;
 256         ULONG sig;
 257         if( ebm ){
 258
 259                 SetRast(ebm->rp,0);
 260                 if( c->signal >= 0 && c->signal != 99 ){
 261
 262                         sig = c->signal;
 263                         //sig = (ULONG)( log( (double)c->signal ) / log( 31.0 )*31.0 );
 264
 265                         SetAPen(ebm->rp,2);
 266                         for(i=0;i<32;i++){
 267                                 if( sig >= i){
 268                                         Move(ebm->rp, i , 15 );
 269                                         Draw(ebm->rp, i , 15-i/2 );
 270                                 }
 271                         }
 272                         SetAPen(ebm->rp,1);
 273                         Move(ebm->rp,0,15);
 274                         Draw(ebm->rp,0,14);
 275                         Draw(ebm->rp,29,0);
 276                         Draw(ebm->rp,31,0);
 277                         Draw(ebm->rp,31,15);
 278                         Draw(ebm->rp,0,15);
 279                 }
 280                 DoMethod( ebm->MUIbitmap , MUIM_Draw );
 281
 282                 /*
 283                 <AcT> Network access type
 284                 0 GSM
 285                 1 Compact GSM
 286                 2 UTRAN
 287                 3 GSM with EGPRS
 288                 4 UTRAN with HSDPA
 289                 5 UTRAN with HSUPA
 290                 6 UTRAN with HSDPA and HSUPA ???
 291                 */
 292
 293                 set( AccessType , MUIA_Text_Contents,
 294                                 c->AccessType == -1 ? "" :
 295                                 c->AccessType == 0 ? "GSM" :
 296                                 c->AccessType == 1 ? "GPRS" :
 297                                 c->AccessType == 2 ? "3G" :
 298                                 c->AccessType == 3 ? "EDGE" :
 299                                 c->AccessType == 4 ? "3.5G" :
 300                                 c->AccessType == 5 ? "3.75G" :
 301                                 c->AccessType == 6 ? "3.8G" :
 302                                                                          "?G"
 303                 );
 304                 set( ModemName , MUIA_Text_Contents, c->modemmodel);
 305         }
 306 }
 307
 308 static void DisconnectFunc(struct Hook *hook, Object *app, APTR *arg)
 309 {
 310
 311         struct Conf *c = *arg;
 312         SendCtrlMsg( PPP_CTRL_SETPHASE , PPP_PHASE_TERMINATE , c );
 313
 314 }
 315
 316 void FindModemUnit(struct Conf *c){
 317         struct EasySerial *Ser=0;
 318         int result = -1;
 319         int i;
 320
 321         if( c->SerUnitNum >= 0 ){
 322                 return;
 323         }
 324
 325         for (i = 0; i < 100; i++)
 326         {
 327                 if( Ser = OpenSerial( c->DeviceName ,i ) ){
 328                         if( TestModem( Ser , c ) ){
 329                                 result = i;
 330                                 DrainSerial( Ser );
 331                                 CloseSerial( Ser );
 332                                 break;
 333                         }
 334                         DrainSerial( Ser );
 335                         CloseSerial( Ser );
 336                 } else break;
 337         }
 338         c->SerUnitNum = result;
 339 }
 340
 341
 342 static void ConnectFunc(struct Hook *hook, Object *app, APTR *arg)
 343 {
 344         struct Conf *c = *arg;
 345         struct EasySerial *Ser=0;
 346
 347         if( c->state == STATE_PLUGGED ){
 348
 349                 // is interfacename configured?
 350                 if( c->InterfaceName[0] == 0 ){
 351                         set( IN_Info , MUIA_Text_Contents, (IPTR)"ppp Interface not configured!");
 352                         return;
 353                 }
 354
 355                 // check if arostcp is running
 356                 if( FindTask("bsdsocket.library") == NULL ){
 357                         set( IN_Info , MUIA_Text_Contents, (IPTR)"AROSTCP is not running!");
 358                         if( StartStack() ){
 359                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"Starting AROSTCP OK");
 360                         }else{
 361                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"Starting AROSTCP FAIL!");
 362                                 return;
 363                         }
 364                 }
 365
 366                 // check ppp.device
 367                 if( FindPort("ppp-control") ){
 368                         // send info request to ppp.device
 369                         SendRequest();
 370                 }else{
 371                         set( OUT_Info, MUIA_Text_Contents, (IPTR)"Can't find ppp.device!");
 372                         set( IN_Info , MUIA_Text_Contents, (IPTR)"Not configured?");
 373                         return;
 374                 }
 375
 376                 if( c->SerUnitNum >=0 ){
 377                         set( IN_Info , MUIA_Text_Contents, (IPTR)"Open Serial Device...");
 378                         set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 379                         if( Ser = OpenSerial( c->DeviceName ,c->SerUnitNum ) ){
 380                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"Modem Test...");
 381                                 //set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 382                                 if( TestModem( Ser , c ) ){
 383                                         UpdateModemInfo( SignalBM , c );
 384                                         set( IN_Info , MUIA_Text_Contents, (IPTR)"DialUp...");
 385                                         //set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 386                                         if( DialUp(Ser,c) ){
 387                                                 CloseSerial(Ser);
 388                                                 if( SendCtrlMsg( PPP_CTRL_OPEN_SERIAL , 0 , c )){
 389                                                         c->state = STATE_OPENDEV;
 390                                                         set( OUT_Info , MUIA_Text_Contents, (IPTR)"OK,Starting PPP...");
 391                                                 }
 392                                         }
 393                                 }
 394                                 CloseSerial(Ser);
 395                         }else c->state = STATE_UNPLUGGED;
 396                 }else c->state = STATE_UNPLUGGED;
 397
 398                 if( c->state != STATE_OPENDEV ){
 399                         set( OUT_Info , MUIA_Text_Contents, (IPTR)"ERROR");
 400                 }
 401         }
 402 }
 403
 404
 405 #define FILEBUFFSIZE 4000
 406
 407 void ConfNetWork(struct PPPcontrolMsg *msg,struct Conf *c){
 408
 409         struct TagItem tags[] =
 410         {
 411                 { SYS_Input,  (IPTR)NULL  },
 412                 { SYS_Output, (IPTR)NULL  },
 413                 { SYS_Error,  (IPTR)NULL  },
 414                 { SYS_Asynch, (IPTR)FALSE },
 415                 { TAG_DONE,   0           }
 416         };
 417
 418     struct Library *MiamiBase;
 419         TEXT arostcppath[256];
 420         UBYTE *buff;
 421
 422         arostcppath[0]=0;
 423         GetVar( "SYS/Packages/AROSTCP" , arostcppath , 256 , LV_VAR);
 424
 425         bug("\n###########################################################\n");
 426         bug("PPP is ONLINE !\n");
 427         bug("Local IP address %d.%d.%d.%d\n",msg->LocalIP[0],msg->LocalIP[1],msg->LocalIP[2],msg->LocalIP[3]);
 428         bug("Remote IP address %d.%d.%d.%d\n",msg->RemoteIP[0],msg->RemoteIP[1],msg->RemoteIP[2],msg->RemoteIP[3]);
 429
 430         if( buff = AllocMem( FILEBUFFSIZE , MEMF_CLEAR|MEMF_PUBLIC ) ){
 431
 432                 bug("Primary DNS address %d.%d.%d.%d\n", msg->PrimaryDNS[0],msg->PrimaryDNS[1],
 433                         msg->PrimaryDNS[2],msg->PrimaryDNS[3] );
 434                 bug("Secondary DNS address %d.%d.%d.%d\n", msg->SecondaryDNS[0],msg->SecondaryDNS[1],
 435                         msg->SecondaryDNS[2],msg->SecondaryDNS[3] );
 436
 437         // Register nameservers with TCP/IP stack
 438                 if( FindTask("bsdsocket.library") != NULL ) {
 439             MiamiBase = OpenLibrary("miami.library", 0);
 440             if(MiamiBase != NULL) {
 441                 ClearDynNameServ();
 442                 struct sockaddr_in ns_addr;
 443
 444                 ns_addr.sin_len = sizeof(ns_addr);
 445                 ns_addr.sin_family = AF_INET;
 446
 447                 ns_addr.sin_addr.s_addr = *(ULONG *)msg->PrimaryDNS;
 448                 AddDynNameServ((struct sockaddr *)&ns_addr);
 449
 450                 ns_addr.sin_addr.s_addr = *(ULONG *)msg->SecondaryDNS;
 451                 AddDynNameServ((struct sockaddr *)&ns_addr);
 452
 453                 EndDynNameServ();
 454                 CloseLibrary(MiamiBase);
 455             }
 456         }
 457
 458                 sprintf(buff,"%s/c/ifconfig %s %d.%d.%d.%d %d.%d.%d.%d",
 459                                 arostcppath,
 460                                 c->InterfaceName,
 461                                 msg->LocalIP[0],msg->LocalIP[1],
 462                                 msg->LocalIP[2],msg->LocalIP[3],
 463                                 msg->RemoteIP[0],msg->RemoteIP[1],
 464                                 msg->RemoteIP[2],msg->RemoteIP[3] );
 465
 466                 bug("Executing command:\"%s\"\n",buff);
 467                 if( SystemTagList( buff , tags ) != 0 )
 468                         bug("command FAIL !!!!\n");
 469
 470                 sprintf(buff,"%s/c/route add default %d.%d.%d.%d",
 471                                 arostcppath,
 472                                 msg->RemoteIP[0],msg->RemoteIP[1],
 473                                 msg->RemoteIP[2],msg->RemoteIP[3] );
 474
 475                 bug("Executing command:\"%s\"\n",buff);
 476                 if(SystemTagList( buff , tags ) != 0 )
 477                         bug("command FAIL !!!!\n");
 478
 479                 bug("\n############################################################*\n");
 480
 481                 FreeMem( buff , FILEBUFFSIZE );
 482         }
 483 }
 484
 485 void HandleMessage(struct PPPcontrolMsg *InfoMsg,struct Conf *c){
 486         if( InfoMsg->Msg.mn_Length == sizeof(struct PPPcontrolMsg)
 487                 &&  InfoMsg->Command == PPP_CTRL_INFO
 488          ){
 489                 if( exPhase != InfoMsg->Phase || exSer != InfoMsg->Ser || exstate !=  c->state ){
 490                         exPhase = InfoMsg->Phase; exSer = InfoMsg->Ser; exstate =  c->state;
 491                         bug("ModemManager:handlemsg phase=%d,ser=%d,state=%d\n",exPhase,exSer,exstate);
 492                 }
 493                 // TERMINATE phase in progress ,dont do nothing
 494                 if(  InfoMsg->Phase == PPP_PHASE_TERMINATE ){
 495                         return;
 496                 }
 497
 498                 // PPP initializing is ready
 499                 if(  c->state == STATE_OPENDEV && InfoMsg->Phase == PPP_PHASE_NETWORK ){
 500                          ConfNetWork( InfoMsg ,c );
 501                          c->state = STATE_NETWORK;
 502                 }
 503
 504                 // serial connection is lost (device unplugged)
 505                 if( c->state != STATE_UNPLUGGED && (! InfoMsg->Ser) ){
 506                           c->state = STATE_PLUGGED;
 507                 }
 508
 509                 // Connection is ok
 510                 if( InfoMsg->Phase == PPP_PHASE_NETWORK &&  InfoMsg->Ser ){
 511                           c->state = STATE_NETWORK;
 512                 }
 513
 514                 // net connection is lost
 515                 if( c->state == STATE_NETWORK &&  InfoMsg->Phase != PPP_PHASE_NETWORK ){
 516                 //      SendCtrlMsg( PPP_CTRL_CLOSE_SERIAL , 0 , c );
 517                         c->state = STATE_PLUGGED;
 518                 }
 519         }
 520 }
 521
 522
 523 int main(void)
 524 {
 525         struct Hook DisconnectHook,ConnectHook;
 526         struct EasyTimer *timer=0;
 527         BYTE buf[STRSIZE];
 528         buf[0]=0;
 529         ULONG sigs;
 530         struct PPPcontrolMsg *CtrlMsg=0;
 531         struct PPPcontrolMsg *InfoMsg=0;
 532         struct MsgPort *CtrlPort=0;
 533         struct EasySerial *Ser=0;
 534         struct Conf *c=0;
 535
 536         struct EasyGraph *INegr=0;
 537         struct EasyGraph *OUTegr=0;
 538
 539         Object *INGraphMUIbm,*OUTGraphMUIbm,*MUISignalBM;
 540
 541         ULONG SpeedIn=0,SpeedOUT=0;
 542
 543         if( ! FindPort(PortName)){
 544         if( timer=OpenTimer() ){
 545         if( CtrlPort = CreatePort(PortName,0) ){
 546         if( CtrlMsg = AllocMem(sizeof(struct PPPcontrolMsg),MEMF_PUBLIC | MEMF_CLEAR)){
 547         if( c = AllocMem(sizeof(struct Conf),MEMF_PUBLIC | MEMF_CLEAR)){
 548
 549                 NEWLIST(&c->atcl);
 550
 551                 for(;;)
 552                 {
 553
 554                         ReadConfig(c);
 555
 556                         c->state = STATE_UNPLUGGED;
 557                         c->signal = -1;
 558                         c->AccessType = -1;
 559                         SpeedIn =0;
 560                         SpeedOUT = 0;
 561
 562                         SetTimer( timer , 0 );
 563                         application = NULL;
 564
 565                         // send info request to ppp.device and wait response
 566                         if( SendRequest() ){
 567                                 bug("ModemManager:wait response\n");
 568                                 sigs = Wait( SIGBREAKF_CTRL_C |
 569                                                         (1L<< CtrlPort->mp_SigBit )
 570                                                         );
 571
 572                                 while( InfoMsg = (struct PPPcontrolMsg*)GetMsg(CtrlPort) ){
 573                                         HandleMessage(InfoMsg,c);
 574                                         ReplyMsg((struct Message *)InfoMsg);
 575                                 }
 576
 577                                 if (sigs & SIGBREAKF_CTRL_C) goto shutdown;
 578                         }
 579
 580                         SetTimer( timer , 1 );
 581                         bug("ModemManager:wait until %s unit %d open.\n",c->DeviceName ,c->SerUnitNum);
 582                         while(c->state == STATE_UNPLUGGED)
 583                         {
 584                                  sigs = Wait( SIGBREAKF_CTRL_C |
 585                                                         (1L<< CtrlPort->mp_SigBit ) |
 586                                                         (1L<< timer->TimeMsg->mp_SigBit )
 587                                                         );
 588
 589                                 // handle incoming messages
 590                                 while( InfoMsg = (struct PPPcontrolMsg*)GetMsg(CtrlPort) )
 591                                         ReplyMsg((struct Message *)InfoMsg);
 592
 593                                 // Check if modem is plugged in.
 594                                 if(GetMsg(timer->TimeMsg)){
 595                                         FindModemUnit(c);
 596                                         if( c->SerUnitNum >= 0 ){
 597                                                 if( Ser = OpenSerial( c->DeviceName ,c->SerUnitNum ) ){
 598                                                         if( TestModem( Ser , c ) ){
 599                                                                  c->state = STATE_PLUGGED;
 600                                                         }
 601                                                         CloseSerial(Ser);
 602                                                 }
 603                                         }
 604                                         SetTimer( timer , 5 );
 605                                 }
 606
 607                                 if (sigs & SIGBREAKF_CTRL_C) goto shutdown;
 608                         }
 609
 610                         bug("ModemManager:Open GUI window\n");
 611
 612                         DisconnectHook.h_Entry = HookEntry;
 613                         DisconnectHook.h_SubEntry = (HOOKFUNC) DisconnectFunc;
 614                         ConnectHook.h_Entry = HookEntry;
 615                         ConnectHook.h_SubEntry = (HOOKFUNC) ConnectFunc;
 616
 617                         application = ApplicationObject,
 618                         SubWindow, window = WindowObject,
 619                                 MUIA_Window_Title,      (IPTR) "ModemManager",
 620                                 MUIA_Window_Activate,TRUE,
 621                                         WindowContents, (IPTR) VGroup,
 622
 623                                                 Child, (IPTR) VGroup,
 624                                                 GroupFrame,
 625                                                         Child, (IPTR) HGroup,
 626                                                                 Child, ModemName = SimpleText("1234567890123"),
 627                                                                 Child, MUISignalBM = BitmapObject,
 628                                                                         MUIA_FixWidth, 32,
 629                                                                         MUIA_FixHeight, 16,
 630                                                                 End,
 631                                                                 Child, AccessType = SimpleText("12345"),
 632                                                         End,
 633                                                         Child, (IPTR) HGroup,
 634                                                                 Child, IN_Info = SimpleText("12345678901"),
 635                                                                 Child, INGraphMUIbm = BitmapObject,
 636                                                                         MUIA_FixWidth, 80,
 637                                                                         MUIA_FixHeight, 16,
 638                                                                 End,
 639                                                         End,
 640                                                         Child, (IPTR) HGroup,
 641                                                                 Child, OUT_Info = SimpleText("12345678901"),
 642                                                                 Child, OUTGraphMUIbm = BitmapObject,
 643                                                                         MUIA_FixWidth, 80,
 644                                                                         MUIA_FixHeight, 16,
 645                                                                 End,
 646                                                         End,
 647
 648                                                 End,
 649                                                 Child, (IPTR) HGroup,
 650                                                         Child, (IPTR) (   ConBut = SimpleButton("   Connect    ")),
 651                                                         Child, (IPTR) (DisConBut = SimpleButton("  Disconnect  ")),
 652                                                 End,
 653                                         End,
 654                                 End,
 655                         End;
 656
 657                         if (application)
 658                         {
 659                                 sigs = 0;
 660
 661                                 DoMethod(
 662                                                 window, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
 663                                                 (IPTR) application, 2, MUIM_Application_ReturnID,
 664                                                 MUIV_Application_ReturnID_Quit
 665                                 );
 666
 667                                 DoMethod(
 668                                         ConBut,MUIM_Notify,MUIA_Pressed,FALSE,
 669                                         application, (IPTR) 3,
 670                                         MUIM_CallHook, &ConnectHook,c
 671                                 );
 672
 673                                 DoMethod(
 674                                         DisConBut,MUIM_Notify,MUIA_Pressed,FALSE,
 675                                         application, (IPTR) 3,
 676                                         MUIM_CallHook, &DisconnectHook,c
 677                                 );
 678
 679
 680                                 set(window,MUIA_Window_Open,TRUE);
 681                                 set(DisConBut,MUIA_Disabled,TRUE);
 682                                 set(   ConBut,MUIA_Disabled,TRUE);
 683
 684                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"");
 685                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 686
 687                                 SignalBM = MakeBitmap(32,16,window,MUISignalBM);
 688                                 INegr = MakeGraph(80,16,window,INGraphMUIbm);
 689                                 OUTegr = MakeGraph(80,16,window,OUTGraphMUIbm);
 690                                 set( INGraphMUIbm , MUIA_ShowMe , FALSE );
 691                                 set( OUTGraphMUIbm , MUIA_ShowMe , FALSE );
 692
 693                                 SetTimer( timer , 1 );
 694                                 SendRequest();
 695
 696                                 UpdateModemInfo( SignalBM , c );
 697
 698                                 while(
 699                                                 DoMethod(
 700                                                         application, MUIM_Application_NewInput, (IPTR) &sigs
 701                                                 ) != MUIV_Application_ReturnID_Quit
 702                                         )
 703                                 {
 704                                         if (sigs){
 705                                                  sigs = Wait(   sigs |
 706                                                                                 SIGBREAKF_CTRL_C |
 707                                                                                 (1L<< CtrlPort->mp_SigBit ) |
 708                                                                                 (1L<< timer->TimeMsg->mp_SigBit )
 709                                                                         );
 710
 711                                                 while( InfoMsg = (struct PPPcontrolMsg*)GetMsg(CtrlPort) ){
 712                                                         //bug("ModemManager: received info message num %d\n",InfoMsg->num);
 713
 714                                                         HandleMessage(InfoMsg,c);
 715
 716                                                         if( c->state == STATE_UNPLUGGED ){
 717                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"Unplugged");
 718                                                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 719                                                                 set(DisConBut, MUIA_Disabled , TRUE );
 720                                                                 set(   ConBut, MUIA_Disabled , TRUE );
 721                                                         }
 722                                                         else if( c->state == STATE_PLUGGED ){
 723                                                                 set( INGraphMUIbm , MUIA_ShowMe , FALSE );
 724                                                                 set( OUTGraphMUIbm , MUIA_ShowMe , FALSE );
 725                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"");
 726                                                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 727                                                                 set(DisConBut, MUIA_Disabled , TRUE );
 728                                                                 set(   ConBut, MUIA_Disabled , FALSE );
 729                                                         }
 730                                                         else if( c->state == STATE_OPENDEV &&  ! InfoMsg->Ser){
 731                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"OpenDevice:");
 732                                                                 snprintf( buf, STRSIZE , "%s unit %d",c->DeviceName,c->SerUnitNum);
 733                                                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)buf);
 734                                                                 set(DisConBut, MUIA_Disabled , FALSE );
 735                                                                 set(   ConBut, MUIA_Disabled , TRUE );
 736                                                         }
 737
 738                                                         else if( c->state == STATE_OPENDEV ){
 739                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"Connection in progress:");
 740                                                                 UBYTE phase = InfoMsg->Phase;
 741
 742                                                                 set( OUT_Info , MUIA_Text_Contents,
 743                                                                         (IPTR)( phase == PPP_PHASE_CONFIGURATION  ? "LCP configuration" :
 744                                                                                         phase == PPP_PHASE_AUTHENTICATION ? "Authentication" :
 745                                                                                         phase == PPP_PHASE_PROTOCOL_CONF  ? "Protocol configuration" :
 746                                                                                                                                                                 "Unknow"
 747                                                                         ));
 748
 749                                                                 set(DisConBut, MUIA_Disabled , FALSE );
 750                                                                 set(   ConBut, MUIA_Disabled , TRUE );
 751                                                                 //set(window,MUIA_Window_Title,(IPTR)c->modemmodel);
 752                                                         }
 753                                                         else if( c->state == STATE_NETWORK ){
 754                                                                 if( InfoMsg->Phase == PPP_PHASE_TERMINATE ){
 755                                                                         set(DisConBut, MUIA_Disabled , TRUE );
 756                                                                         set(   ConBut, MUIA_Disabled , TRUE );
 757                                                                         set( INGraphMUIbm , MUIA_ShowMe , FALSE );
 758                                                                         set( OUTGraphMUIbm , MUIA_ShowMe , FALSE );
 759                                                                         set( IN_Info , MUIA_Text_Contents, (IPTR)"Terminate...");
 760                                                                         set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 761                                                                 } else{
 762                                                                         SpeedIn = InfoMsg->SpeedIn;
 763                                                                         SpeedOUT = InfoMsg->SpeedOut;
 764
 765                                                                         speedstr(buf," In",SpeedIn);
 766                                                                         set( IN_Info , MUIA_Text_Contents, (IPTR)buf);
 767                                                                         speedstr(buf,"Out",SpeedOUT);
 768                                                                         set( OUT_Info , MUIA_Text_Contents, (IPTR)buf);
 769
 770                                                                         set(DisConBut, MUIA_Disabled , FALSE );
 771                                                                         set(   ConBut, MUIA_Disabled , TRUE );
 772
 773                                                                         set( INGraphMUIbm , MUIA_ShowMe , TRUE );
 774                                                                         set( OUTGraphMUIbm , MUIA_ShowMe , TRUE );
 775                                                                 }
 776                                                         }
 777
 778                                                         ReplyMsg((struct Message *)InfoMsg);
 779                                                 //bug("ModemManager: ReplyMsg OK\n");
 780                                                 }
 781
 782
 783                                                 if(GetMsg(timer->TimeMsg)){
 784
 785                                                         if( c->state == STATE_NETWORK ){
 786                                                                 speedstr(buf," In",SpeedIn);
 787                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)buf);
 788                                                                 speedstr(buf,"Out",SpeedOUT);
 789                                                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)buf);
 790                                                                 UpdateGraph(INegr,(FLOAT)SpeedIn);
 791                                                                 UpdateGraph(OUTegr,(FLOAT)SpeedOUT);
 792                                                         }
 793
 794                                                         // test if modem is unplugged
 795                                                         if( c->state == STATE_PLUGGED ){
 796                                                                 if( Ser = OpenSerial( c->DeviceName ,c->SerUnitNum ) ){
 797                                                                          CloseSerial(Ser);
 798                                                                          //UpdateModemInfo( SignalBM , c );
 799                                                                 } else
 800                                                                         c->state = STATE_UNPLUGGED;
 801                                                         }
 802
 803                                                         if( c->state == STATE_PLUGGED ){
 804                                                                 set( OUT_Info , MUIA_Text_Contents, (IPTR)"");
 805                                                                 set( IN_Info , MUIA_Text_Contents, (IPTR)"");
 806                                                                 set(DisConBut, MUIA_Disabled , TRUE );
 807                                                                 set(   ConBut, MUIA_Disabled , FALSE );
 808                                                         }
 809
 810                                                         SetTimer( timer , TIMERVALUE );
 811                                                 }
 812
 813                                                 if (sigs & SIGBREAKF_CTRL_C) goto shutdown;
 814                                         }
 815
 816                                         if( c->state == STATE_UNPLUGGED ) break;
 817                                 } //GUI loop
 818
 819                                 // MUIV_Application_ReturnID_Quit ?
 820                                 if( c->state != STATE_UNPLUGGED ) break;
 821                         }
 822                         bug("ModemManager:Device Unplugged -> Close GUI window\n");
 823                         SetTimer( timer , 0 );
 824                         MUI_DisposeObject(application);
 825                         application=NULL;
 826                         CloseBitmap(SignalBM);
 827                         CloseGraph(INegr);
 828                         CloseGraph(OUTegr);
 829                 } // main loop
 830
 831         }}}}}
 832
 833         // close all
 834         shutdown:
 835         bug("ModemManager:ShutDown\n");
 836         if(application) MUI_DisposeObject(application);
 837         CloseBitmap(SignalBM);
 838         CloseGraph(INegr);
 839         CloseGraph(OUTegr);
 840         CloseTimer(timer);
 841
 842         struct at_command  *atc;
 843         while( atc = (struct at_command *)RemHead( &c->atcl ) ){
 844                 FreeMem( atc , sizeof(struct at_command) );
 845         }
 846
 847         if(CtrlPort){
 848                 Forbid();
 849                         while( GetMsg(CtrlPort) ) ReplyMsg((struct Message *)CtrlMsg);
 850                         DeletePort(CtrlPort);
 851                 Permit();
 852         }
 853
 854         if( c ) FreeMem( c , sizeof(struct Conf));
 855         if( CtrlMsg ) FreeMem(CtrlMsg , sizeof(struct PPPcontrolMsg));
 856
 857   return 0;
 858 }