Kernel/PTYs - NL->CR translation (disabled)
[tpg/acess2.git] / 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 }

UCC git Repository :: git.ucc.asn.au