Usermode/Applications/irc_src/main.c

   1 /*
   2  * Acess2 IRC Client
   3  */
   4 #include <acess/sys.h>
   5 #include <stdlib.h>
   6 #include <stdio.h>
   7 #include <string.h>
   8 #include <net.h>
   9 #include <readline.h>
  10 #include <acess/devices/pty.h>
  11 #include <stdarg.h>
  12
  13 // === TYPES ===
  14 typedef struct sServer {
  15         struct sServer  *Next;
  16          int    FD;
  17         char    InBuf[BUFSIZ+1];
  18          int    ReadPos;
  19         char    Name[];
  20 } tServer;
  21
  22 typedef struct sMessage
  23 {
  24         struct sMessage *Next;
  25         time_t  Timestamp;
  26         tServer *Server;
  27          int    Type;
  28         char    *Source;        // Pointer into `Data`
  29         char    Data[];
  30 }       tMessage;
  31
  32 typedef struct sWindow
  33 {
  34         struct sWindow  *Next;
  35         tMessage        *Messages;
  36         tServer *Server;        //!< Canonical server (can be NULL)
  37          int    ActivityLevel;
  38         char    Name[]; // Channel name / remote user
  39 }       tWindow;
  40
  41 enum eMessageTypes
  42 {
  43         MSG_TYPE_NULL,
  44         MSG_TYPE_SERVER,        // Server message
  45
  46         MSG_TYPE_NOTICE,        // NOTICE command
  47         MSG_TYPE_JOIN,  // JOIN command
  48         MSG_TYPE_PART,  // PART command
  49         MSG_TYPE_QUIT,  // QUIT command
  50
  51         MSG_TYPE_STANDARD,      // Standard line
  52         MSG_TYPE_ACTION,        // /me
  53
  54         MSG_TYPE_UNK
  55 };
  56
  57 // === PROTOTYPES ===
  58  int    main(int argc, const char *argv[], const char *envp[]);
  59  int    MainLoop(void);
  60  int    ParseArguments(int argc, const char *argv[]);
  61  int    ParseUserCommand(char *String);
  62 // ---
  63 tServer *Server_Connect(const char *Name, const char *AddressString, short PortNumber);
  64 tMessage        *Message_AppendF(tServer *Server, int Type, const char *Source, const char *Dest, const char *Message, ...) __attribute__((format(__printf__,5,6)));
  65 tMessage        *Message_Append(tServer *Server, int Type, const char *Source, const char *Dest, const char *Message);
  66 tWindow *Window_Create(tServer *Server, const char *Name);
  67 void    Redraw_Screen(void);
  68
  69  int    ProcessIncoming(tServer *Server);
  70 // --- Helpers
  71 void    SetCursorPos(int Row, int Col);
  72  int    writef(int FD, const char *Format, ...);
  73  int    OpenTCP(const char *AddressString, short PortNumber);
  74 char    *GetValue(char *Str, int *Ofs);
  75 static inline int       isdigit(int ch);
  76
  77 // === GLOBALS ===
  78 char    *gsUsername = "user";
  79 char    *gsHostname = "acess";
  80 char    *gsRealName = "Acess2 IRC Client";
  81 char    *gsNickname = "acess";
  82 tServer *gpServers;
  83 tWindow gWindow_Status = {
  84         NULL, NULL, NULL,       // No next, empty list, no server
  85         0, {""} // No activity, empty name (rendered as status)
  86 };
  87 tWindow *gpWindows = &gWindow_Status;
  88 tWindow *gpCurrentWindow = &gWindow_Status;
  89  int    giTerminal_Width = 80;
  90  int    giTerminal_Height = 25;
  91
  92 // ==== CODE ====
  93 void ExitHandler(void)
  94 {
  95         printf("\x1B[?1047l");
  96         printf("Quit\n");
  97 }
  98
  99 int main(int argc, const char *argv[], const char *envp[])
 100 {
 101          int    tmp;
 102
 103         // Parse Command line
 104         if( (tmp = ParseArguments(argc, argv)) )        return tmp;
 105
 106         atexit(ExitHandler);
 107
 108         if( _SysIOCtl(1, DRV_IOCTL_TYPE, NULL) != DRV_TYPE_TERMINAL ) {
 109                 fprintf(stderr, "note: assuming 80x25, can't get terminal dimensions\n");
 110                 giTerminal_Width = 80;
 111                 giTerminal_Height = 25;
 112         }
 113         else {
 114                 struct ptydims  dims;
 115                 _SysIOCtl(1, PTY_IOCTL_GETDIMS, &dims);
 116                 giTerminal_Width = dims.W;
 117                 giTerminal_Height = dims.H;
 118         }
 119
 120         printf("\x1B[?1047h");
 121         printf("\x1B[%i;%ir", 0, giTerminal_Height-1);
 122
 123         SetCursorPos(giTerminal_Height-1, 0);
 124         printf("[(status)] ");
 125
 126         // HACK: Static server entry
 127         // UCC (University [of Western Australia] Computer Club) IRC Server
 128         gWindow_Status.Server = Server_Connect( "UCC", "130.95.13.18", 6667 );
 129         // Freenode (#osdev)
 130 //      gWindow_Status.Server = Server_Connect( "Freenode", "89.16.176.16", 6667 );
 131         // Local servers
 132 //      gWindow_Status.Server = Server_Connect( "VMHost", "10.0.2.2", 6667 );
 133 //      gWindow_Status.Server = Server_Connect( "BitlBee", "192.168.1.39", 6667 );
 134
 135         if( !gWindow_Status.Server )
 136                 return -1;
 137
 138         MainLoop();
 139
 140         for( tServer *srv = gpServers; srv; srv = srv->Next )
 141                 _SysClose(srv->FD);
 142
 143         return 0;
 144 }
 145
 146 int MainLoop(void)
 147 {
 148         SetCursorPos(giTerminal_Height-1, 0);
 149         printf("[(status)] ");
 150         fflush(stdout);
 151
 152         tReadline *readline_info = Readline_Init(1);
 153
 154         for( ;; )
 155         {
 156                 fd_set  readfds, errorfds;
 157                  int    maxFD = 0;
 158
 159                 FD_ZERO(&readfds);
 160                 FD_ZERO(&errorfds);
 161                 FD_SET(0, &readfds);    // stdin
 162
 163                 fflush(stdout);
 164
 165                 // Fill server FDs in fd_set
 166                 for( tServer *srv = gpServers; srv; srv = srv->Next )
 167                 {
 168                         FD_SET(srv->FD, &readfds);
 169                         FD_SET(srv->FD, &errorfds);
 170                         if( srv->FD > maxFD )
 171                                 maxFD = srv->FD;
 172                 }
 173
 174                 int rv = _SysSelect(maxFD+1, &readfds, 0, &errorfds, NULL, 0);
 175                 if( rv == -1 )  break;
 176
 177                 if(FD_ISSET(0, &readfds))
 178                 {
 179                         // User input
 180                         char    *cmd = Readline_NonBlock(readline_info);
 181                         if( cmd )
 182                         {
 183                                 if( cmd[0] )
 184                                 {
 185                                         ParseUserCommand(cmd);
 186                                 }
 187                                 free(cmd);
 188                                 // Prompt
 189                                 SetCursorPos(giTerminal_Height-1, 0);
 190                                 printf("\x1B[2K");      // Clear line
 191                                 if( gpCurrentWindow->Name[0] )
 192                                         printf("[%s:%s] ",
 193                                                 gpCurrentWindow->Server->Name, gpCurrentWindow->Name);
 194                                 else
 195                                         printf("[(status)] ");
 196                         }
 197                 }
 198
 199                 // Server response
 200                 for( tServer *srv = gpServers; srv; srv = srv->Next )
 201                 {
 202                         if(FD_ISSET(srv->FD, &readfds))
 203                         {
 204                                 if( ProcessIncoming(srv) != 0 ) {
 205                                         // Oops, error
 206                                         _SysDebug("ProcessIncoming failed on FD%i (Server %p %s)",
 207                                                 srv->FD, srv, srv->Name);
 208                                         return 1;
 209                                 }
 210                         }
 211
 212                         if(FD_ISSET(srv->FD, &errorfds))
 213                         {
 214                                 _SysDebug("Error on FD%i (Server %p %s)",
 215                                         srv->FD, srv, srv->Name);
 216                                 return 1;
 217                         }
 218                 }
 219         }
 220         return 0;
 221 }
 222
 223 /**
 224  * \todo Actually implement correctly :)
 225  */
 226 int ParseArguments(int argc, const char *argv[])
 227 {
 228         return 0;
 229 }
 230
 231
 232 void Cmd_join(char *ArgString)
 233 {
 234          int    pos=0;
 235         char    *channel_name = GetValue(ArgString, &pos);
 236
 237         if( gpCurrentWindow->Server )
 238         {
 239                 gpCurrentWindow = Window_Create(gpCurrentWindow->Server, channel_name);
 240                 Redraw_Screen();
 241                 writef(gpCurrentWindow->Server->FD, "JOIN :%s\n", channel_name);
 242         }
 243 }
 244
 245 void Cmd_quit(char *ArgString)
 246 {
 247         const char *quit_message = ArgString;
 248         if( quit_message == NULL || quit_message[0] == '\0' )
 249                 quit_message = "/quit - Acess2 IRC Client";
 250
 251         for( tServer *srv = gpServers; srv; srv = srv->Next )
 252         {
 253                 writef(srv->FD, "QUIT :%s\n", quit_message);
 254         }
 255
 256         exit(0);
 257 }
 258
 259 void Cmd_window(char *ArgString)
 260 {
 261          int    pos = 0;
 262         char    *window_id = GetValue(ArgString, &pos);
 263          int    window_num = atoi(window_id);
 264
 265         if( window_num > 0 )
 266         {
 267                 tWindow *win;
 268                 window_num --;  // Move to base 0
 269                 // Get `window_num`th window
 270                 for( win = gpWindows; win && window_num--; win = win->Next );
 271                 if( win ) {
 272                         gpCurrentWindow = win;
 273                         Redraw_Screen();
 274                 }
 275                 // Otherwise, silently ignore
 276         }
 277         else
 278         {
 279                 window_num = 1;
 280                 for( tWindow *win = gpWindows; win; win = win->Next, window_num ++ )
 281                 {
 282                         if( win->Name[0] ) {
 283                                 Message_AppendF(NULL, MSG_TYPE_SERVER, "client", "",
 284                                         "%i: %s/%s", window_num, win->Server->Name, win->Name);
 285                         }
 286                         else {
 287                                 Message_AppendF(NULL, MSG_TYPE_SERVER, "client", "",
 288                                         "%i: (status)", window_num);
 289                         }
 290                 }
 291         }
 292 }
 293
 294 const struct {
 295         const char *Name;
 296         void    (*Fcn)(char *ArgString);
 297 } caCommands[] = {
 298         {"join", Cmd_join},
 299         {"quit", Cmd_quit},
 300         {"window", Cmd_window},
 301         {"win",    Cmd_window},
 302         {"w",      Cmd_window},
 303 };
 304 const int ciNumCommands = sizeof(caCommands)/sizeof(caCommands[0]);
 305
 306 /**
 307  * \brief Handle a line from the prompt
 308  */
 309 int ParseUserCommand(char *String)
 310 {
 311         if( String[0] == '/' )
 312         {
 313                 char    *command;
 314                  int    pos = 0;
 315
 316                 command = GetValue(String, &pos)+1;
 317
 318                 // TODO: Prefix matches
 319                  int    cmdIdx = -1;
 320                 for( int i = 0; i < ciNumCommands; i ++ )
 321                 {
 322                         if( strcmp(command, caCommands[i].Name) == 0 ) {
 323                                 cmdIdx = i;
 324                                 break;
 325                         }
 326                 }
 327                 if( cmdIdx != -1 ) {
 328                         caCommands[cmdIdx].Fcn(String+pos);
 329                 }
 330                 else
 331                 {
 332                         Message_AppendF(NULL, MSG_TYPE_SERVER, "client", "", "Unknown command %s", command);
 333                 }
 334         }
 335         else
 336         {
 337                 // Message
 338                 // - Only send if server is valid and window name is non-empty
 339                 if( gpCurrentWindow->Server && gpCurrentWindow->Name[0] )
 340                 {
 341                         Message_Append(gpCurrentWindow->Server, MSG_TYPE_STANDARD,
 342                                 gsNickname, gpCurrentWindow->Name, String);
 343                         writef(gpCurrentWindow->Server->FD,
 344                                 "PRIVMSG %s :%s\n", gpCurrentWindow->Name,
 345                                 String
 346                                 );
 347                 }
 348         }
 349
 350         return 0;
 351 }
 352
 353 /**
 354  * \brief Connect to a server
 355  */
 356 tServer *Server_Connect(const char *Name, const char *AddressString, short PortNumber)
 357 {
 358         tServer *ret;
 359
 360         ret = calloc(1, sizeof(tServer) + strlen(Name) + 1);
 361
 362         strcpy(ret->Name, Name);
 363
 364         // Connect to the remove server
 365         ret->FD = OpenTCP( AddressString, PortNumber );
 366         if( ret->FD == -1 ) {
 367                 fprintf(stderr, "%s: Unable to create socket\n", Name);
 368                 return NULL;
 369         }
 370
 371         // Append to open list
 372         ret->Next = gpServers;
 373         gpServers = ret;
 374
 375         // Read some initial data
 376         Message_Append(NULL, MSG_TYPE_SERVER, Name, "", "Connection opened");
 377         ProcessIncoming(ret);
 378
 379         // Identify
 380         writef(ret->FD, "USER %s %s %s : %s\n", gsUsername, gsHostname, AddressString, gsRealName);
 381         writef(ret->FD, "NICK %s\n", gsNickname);
 382         Message_Append(NULL, MSG_TYPE_SERVER, Name, "", "Identified");
 383         //printf("%s: Identified\n", Name);
 384
 385         return ret;
 386 }
 387
 388 tMessage *Message_AppendF(tServer *Server, int Type, const char *Source, const char *Dest, const char *Message, ...)
 389 {
 390         va_list args;
 391          int    len;
 392         va_start(args, Message);
 393         len = vsnprintf(NULL, 0, Message, args);
 394         va_end(args);
 395
 396         char    buf[len+1];
 397         va_start(args, Message);
 398         vsnprintf(buf, len+1, Message, args);
 399         va_end(args);
 400
 401         return Message_Append(Server, Type, Source, Dest, buf);
 402 }
 403
 404 tMessage *Message_Append(tServer *Server, int Type, const char *Source, const char *Dest, const char *Message)
 405 {
 406         tWindow *win = NULL;
 407          int    msgLen = strlen(Message);
 408
 409         // Server==NULL indicates an internal message
 410         if( Server == NULL || Source[0] == '\0' )
 411         {
 412                 win = &gWindow_Status;
 413         }
 414         // Determine if it's a channel or PM
 415         else if( Dest[0] == '#' || Dest[0] == '&' )     // TODO: Better determining here
 416         {
 417                 for(win = gpWindows; win; win = win->Next)
 418                 {
 419                         if( win->Server == Server && strcmp(win->Name, Dest) == 0 )
 420                         {
 421                                 break;
 422                         }
 423                 }
 424                 if( !win ) {
 425                         //win = Window_Create(Server, Dest);
 426                         win = &gWindow_Status;  // Stick it in the status window, just in case
 427                 }
 428         }
 429         #if 0
 430         else if( strcmp(Dest, Server->Nick) != 0 )
 431         {
 432                 // Umm... message for someone who isn't us?
 433                 win = &gWindow_Status;  // Stick it in the status window, just in case
 434         }
 435         #endif
 436         // Server message?
 437         else if( strchr(Source, '.') )  // TODO: And again, less hack please
 438         {
 439                 #if 1
 440                 for(win = gpWindows; win; win = win->Next)
 441                 {
 442                         if( win->Server == Server && strcmp(win->Name, Source) == 0 )
 443                         {
 444                                 break;
 445                         }
 446                 }
 447                 #endif
 448                 if( !win ) {
 449                         win = &gWindow_Status;
 450                 }
 451
 452                 // Set source to the server name (instead of the hostname)
 453                 Source = Server->Name;
 454         }
 455         // Private message
 456         else
 457         {
 458                 for(win = gpWindows; win; win = win->Next)
 459                 {
 460                         if( win->Server == Server && strcmp(win->Name, Source) == 0 )
 461                         {
 462                                 break;
 463                         }
 464                 }
 465                 if( !win ) {
 466                         win = Window_Create(Server, Dest);
 467                 }
 468         }
 469
 470         // Create message cache
 471         _SysDebug("Win (%s) msg: <%s> %s", win->Name, Source, Message);
 472         tMessage        *ret;
 473         ret = malloc( sizeof(tMessage) + msgLen + 1 + strlen(Source) + 1 );
 474         ret->Source = ret->Data + msgLen + 1;
 475         strcpy(ret->Source, Source);
 476         strcpy(ret->Data, Message);
 477         ret->Type = Type;
 478         ret->Server = Server;
 479
 480         // Append to window message list
 481         ret->Next = win->Messages;
 482         win->Messages = ret;
 483
 484         // Print now if current window
 485         if( win == gpCurrentWindow )
 486         {
 487                 printf("\33[s");
 488                 printf("\33[T");        // Scroll down 1 (free space below)
 489                 SetCursorPos(giTerminal_Height-2, 0);
 490                  int    prefixlen = strlen(Source) + 3;
 491                  int    avail = giTerminal_Width - prefixlen;
 492                  int    msglen = strlen(Message);
 493                 printf("[%s] %.*s", Source, avail, Message);
 494                 while( msglen > avail ) {
 495                         msglen -= avail;
 496                         Message += avail;
 497                         printf("\33[T");
 498                         SetCursorPos(giTerminal_Height-2, prefixlen);
 499                         printf("%.*s", avail, Message);
 500                 }
 501                 printf("\x1b[u");
 502         }
 503
 504         return ret;
 505 }
 506
 507 tWindow *Window_Create(tServer *Server, const char *Name)
 508 {
 509         tWindow *ret, *prev = NULL;
 510          int    num = 1;
 511
 512         // Get the end of the list
 513         // TODO: Cache this instead
 514         for( ret = gpCurrentWindow; ret; prev = ret, ret = ret->Next )
 515                 num ++;
 516
 517         ret = malloc(sizeof(tWindow) + strlen(Name) + 1);
 518         ret->Messages = NULL;
 519         ret->Server = Server;
 520         ret->ActivityLevel = 1;
 521         strcpy(ret->Name, Name);
 522
 523         if( prev ) {
 524                 ret->Next = prev->Next;
 525                 prev->Next = ret;
 526         }
 527         else {  // Shouldn't happen really
 528                 ret->Next = gpWindows;
 529                 gpWindows = ret;
 530         }
 531
 532 //      printf("Win %i %s:%s created\n", num, Server->Name, Name);
 533
 534         return ret;
 535 }
 536
 537 void Redraw_Screen(void)
 538 {
 539          int    y = 0;
 540         tMessage        *msg;
 541
 542         printf("\x1B[2J");      // Clear screen
 543         printf("\x1B[0;0H");    // Reset cursor
 544
 545         msg = gpCurrentWindow->Messages;
 546
 547         // TODO: Title bar?
 548
 549         // Note: This renders from the bottom up
 550         for( y = giTerminal_Height - 1; y -- && msg; msg = msg->Next)
 551         {
 552                  int    msglen = strlen(msg->Data);
 553                  int    prefix_len = 3 + strlen(msg->Source);
 554                  int    line_avail = giTerminal_Width - prefix_len;
 555                  int    i = 0, done = 0;
 556
 557                 y -= msglen / line_avail;       // Extra lines (y-- above handles the 1 line case)
 558                 SetCursorPos(y, 0);
 559                 printf("[%s] ", msg->Source);
 560
 561                 while(done < msglen) {
 562                         done += printf("%.*s", line_avail, msg->Data+done);
 563                         i ++;
 564                         SetCursorPos(y+i, prefix_len);
 565                 }
 566         }
 567
 568         // Bottom line is rendered by the prompt
 569 }
 570
 571 void Cmd_PRIVMSG(tServer *Server, const char *Dest, const char *Src, const char *Message)
 572 {
 573         Message_Append(Server, MSG_TYPE_STANDARD, Dest, Src, Message);
 574         //printf("<%s:%s:%s> %s\n", Server->Name, Dest, Src, Message);
 575 }
 576
 577 void ParseServerLine_Numeric(tServer *Server, const char *ident, int Num, char *Line)
 578 {
 579          int    pos = 0;
 580         const char *message;
 581         const char *user = GetValue(Line, &pos);
 582
 583         if( Line[pos] == ':' ) {
 584                 message = Line + pos + 1;
 585         }
 586         else {
 587                 message = GetValue(Line, &pos);
 588         }
 589
 590         switch(Num)
 591         {
 592         case 332:       // Topic
 593                 user = message; // Channel
 594                 message = Line + pos + 1;       // Topic
 595                 Message_AppendF(Server, MSG_TYPE_SERVER, user, user, "Topic: %s", message);
 596                 break;
 597         case 333:       // Topic set by
 598                 user = message; // Channel
 599                 message = GetValue(Line, &pos); // User
 600                 GetValue(Line, &pos);   // Timestamp
 601                 Message_AppendF(Server, MSG_TYPE_SERVER, user, user, "Set by %s", message);
 602                 break;
 603         case 353:       // /NAMES list
 604                 // <user> = <channel> :list
 605                 // '=' was eaten in and set to message
 606                 user = GetValue(Line, &pos);    // Actually channel
 607                 message = Line + pos + 1;       // List
 608                 Message_AppendF(Server, MSG_TYPE_SERVER, user, user, "Names: %s", message);
 609                 break;
 610         case 366:       // end of /NAMES list
 611                 // <user> <channel> :msg
 612                 user = message;
 613                 message = Line + pos + 1;
 614                 Message_Append(Server, MSG_TYPE_SERVER, user, user, message);
 615                 break;
 616         case 372:       // MOTD Data
 617         case 375:       // MOTD Start
 618         case 376:       // MOTD End
 619
 620         default:
 621                 //printf("[%s] %i %s\n", Server->Name, num, message);
 622                 Message_Append(Server, MSG_TYPE_SERVER, ident, user, message);
 623                 break;
 624         }
 625 }
 626
 627 void ParseServerLine_String(tServer *Server, const char *ident, const char *cmd, char *Line)
 628 {
 629          int    pos = 0;
 630         _SysDebug("ident=%s,cmd=%s,Line=%s", ident, cmd, Line);
 631         if( strcmp(cmd, "NOTICE") == 0 )
 632         {
 633                 const char *class = GetValue(Line, &pos);
 634                 _SysDebug("NOTICE class='%s'", class);
 635
 636                 const char *message = (Line[pos] == ':') ? Line + pos + 1 : GetValue(Line, &pos);
 637
 638                 //printf("[%s] NOTICE %s: %s\n", Server->Name, ident, message);
 639                 char *ident_bang = strchr(ident, '!');
 640                 if( ident_bang ) {
 641                         *ident_bang = '\0';
 642                 }
 643                 Message_Append(Server, MSG_TYPE_NOTICE, ident, "", message);
 644         }
 645         else if( strcmp(cmd, "PRIVMSG") == 0 )
 646         {
 647                 const char *dest = GetValue(Line, &pos);
 648                 const char *message = (Line[pos] == ':') ? Line + pos + 1 : GetValue(Line, &pos);
 649
 650                 // TODO: Catch when the privmsg is addressed to the user
 651
 652 //              Cmd_PRIVMSG(Server, dest, ident, message);
 653                 char *ident_bang = strchr(ident, '!');
 654                 if( ident_bang ) {
 655                         *ident_bang = '\0';
 656                 }
 657                 Message_Append(Server, MSG_TYPE_STANDARD, ident, dest, message);
 658         }
 659         else if( strcmp(cmd, "JOIN" ) == 0 )
 660         {
 661                 const char      *channel = Line + pos + 1;
 662
 663                 Message_AppendF(Server, MSG_TYPE_JOIN, "", channel, "%s has joined", ident);
 664                 //Window_Create(Server, channel);
 665         }
 666         else if( strcmp(cmd, "PART" ) == 0 )
 667         {
 668                 const char      *channel = Line + pos + 1;
 669
 670                 Message_AppendF(Server, MSG_TYPE_PART, "", channel, "%s has left", ident);
 671                 //Window_Create(Server, channel);
 672         }
 673         else
 674         {
 675                 Message_AppendF(Server, MSG_TYPE_SERVER, "", "", "Unknown message %s (%s)", cmd, Line);
 676         }
 677 }
 678
 679 /**
 680  */
 681 void ParseServerLine(tServer *Server, char *Line)
 682 {
 683          int    pos = 0;
 684
 685         _SysDebug("[%s] %s", Server->Name, Line);
 686
 687         // Message?
 688         if( *Line == ':' )
 689         {
 690                 pos ++;
 691                 const char *ident = GetValue(Line, &pos);       // Ident (user or server)
 692                 const char *cmd = GetValue(Line, &pos);
 693
 694                 // Numeric command
 695                 if( isdigit(cmd[0]) && isdigit(cmd[1]) && isdigit(cmd[2]) )
 696                 {
 697                          int    num;
 698                         num  = (cmd[0] - '0') * 100;
 699                         num += (cmd[1] - '0') * 10;
 700                         num += (cmd[2] - '0') * 1;
 701
 702                         ParseServerLine_Numeric(Server, ident, num, Line+pos);
 703                 }
 704                 else
 705                 {
 706                         ParseServerLine_String(Server, ident, cmd, Line+pos);
 707                 }
 708         }
 709         else {
 710                 const char *cmd = GetValue(Line, &pos);
 711
 712                 if( strcmp(cmd, "PING") == 0 ) {
 713                         writef(Server->FD, "PONG %s\n", gsHostname);
 714
 715                 }
 716                 else {
 717                         // Command to client
 718                         Message_AppendF(NULL, MSG_TYPE_UNK, "", "", "Client Command: %s", Line);
 719                 }
 720         }
 721 }
 722
 723 /**
 724  * \brief Process incoming lines from the server
 725  */
 726 int ProcessIncoming(tServer *Server)
 727 {
 728         char    *ptr, *newline;
 729          int    len;
 730
 731         // While there is data in the buffer, read it into user memory and
 732         // process it line by line
 733         // ioctl#8 on a TCP client gets the number of bytes in the recieve buffer
 734         // - Used to avoid blocking
 735         #if NON_BLOCK_READ
 736         while( (len = _SysIOCtl(Server->FD, 8, NULL)) > 0 )
 737         {
 738         #endif
 739                 // Read data
 740                 len = _SysRead(Server->FD, &Server->InBuf[Server->ReadPos], BUFSIZ - Server->ReadPos);
 741                 if( len == -1 ) {
 742                         return -1;
 743                 }
 744                 Server->InBuf[Server->ReadPos + len] = '\0';
 745
 746                 // Break into lines
 747                 ptr = Server->InBuf;
 748                 while( (newline = strchr(ptr, '\n')) )
 749                 {
 750                         *newline = '\0';
 751                         if( newline[-1] == '\r' )       newline[-1] = '\0';
 752                         ParseServerLine(Server, ptr);
 753                         ptr = newline + 1;
 754                 }
 755
 756                 // Handle incomplete lines
 757                 if( ptr - Server->InBuf < len + Server->ReadPos ) {
 758                         // Update the read position
 759                         // InBuf ReadPos    ptr          ReadPos+len
 760                         // | old | new used | new unused |
 761                         Server->ReadPos = len + Server->ReadPos - (ptr - Server->InBuf);
 762                         // Copy stuff back (moving "new unused" to the start of the buffer)
 763                         memcpy(Server->InBuf, ptr, Server->ReadPos);
 764                 }
 765                 else {
 766                         Server->ReadPos = 0;
 767                 }
 768         #if NON_BLOCK_READ
 769         }
 770         #endif
 771
 772         return 0;
 773 }
 774
 775 /**
 776  * \brief Write a formatted string to a file descriptor
 777  *
 778  */
 779 int writef(int FD, const char *Format, ...)
 780 {
 781         va_list args;
 782          int    len;
 783
 784         va_start(args, Format);
 785         len = vsnprintf(NULL, 0, Format, args);
 786         va_end(args);
 787
 788         {
 789                 char    buf[len+1];
 790                 va_start(args, Format);
 791                 vsnprintf(buf, len+1, Format, args);
 792                 va_end(args);
 793
 794                 return _SysWrite(FD, buf, len);
 795         }
 796 }
 797
 798 /**
 799  * \brief Initialise a TCP connection to \a AddressString on port \a PortNumber
 800  */
 801 int OpenTCP(const char *AddressString, short PortNumber)
 802 {
 803          int    fd, addrType;
 804         char    addrBuffer[8];
 805
 806         // Parse IP Address
 807         addrType = Net_ParseAddress(AddressString, addrBuffer);
 808         if( addrType == 0 ) {
 809                 fprintf(stderr, "Unable to parse '%s' as an IP address\n", AddressString);
 810                 _SysDebug("Unable to parse '%s' as an IP address\n", AddressString);
 811                 return -1;
 812         }
 813
 814         // Finds the interface for the destination address
 815         fd = Net_OpenSocket(addrType, addrBuffer, "tcpc");
 816         if( fd == -1 ) {
 817                 fprintf(stderr, "Unable to open TCP Client to '%s'\n", AddressString);
 818                 _SysDebug("Unable to open TCP client to '%s'\n", AddressString);
 819                 return -1;
 820         }
 821
 822         // Set remote port and address
 823 //      printf("Setting port and remote address\n");
 824         _SysIOCtl(fd, 5, &PortNumber);
 825         _SysIOCtl(fd, 6, addrBuffer);
 826
 827         // Connect
 828 //      printf("Initiating connection\n");
 829         if( _SysIOCtl(fd, 7, NULL) == 0 ) {
 830                 // Shouldn't happen :(
 831                 fprintf(stderr, "Unable to start connection\n");
 832                 return -1;
 833         }
 834
 835         // Return descriptor
 836         return fd;
 837 }
 838
 839 /**
 840  * \brief Read a space-separated value from a string
 841  */
 842 char *GetValue(char *Src, int *Ofs)
 843 {
 844          int    pos = *Ofs;
 845         char    *ret = Src + pos;
 846         char    *end;
 847
 848         if( !Src )      return NULL;
 849
 850         while( *ret == ' ' )    ret ++;
 851
 852         end = strchr(ret, ' ');
 853         if( end ) {
 854                 *end = '\0';
 855         }
 856         else {
 857                 end = ret + strlen(ret) - 1;
 858         }
 859
 860         end ++ ;
 861         while( *ret == ' ' )    end ++;
 862         *Ofs = end - Src;
 863
 864         return ret;
 865 }
 866
 867 void SetCursorPos(int Row, int Col)
 868 {
 869         printf("\x1B[%i;%iH", Row, Col);
 870 }
 871
 872 static inline int isdigit(int ch)
 873 {
 874         return '0' <= ch && ch < '9';
 875 }