contiki/apps/ircc.c - contiki-1.x - Gitiles

 /*
  * Copyright (c) 2004, Adam Dunkels.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. Neither the name of the Institute nor the names of its contributors
  *    may be used to endorse or promote products derived from this software
  *    without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  * SUCH DAMAGE.
  *
  * This file is part of the Contiki operating system.
  *
  * Author: Adam Dunkels <adam@sics.se>
  *
  * $Id: ircc.c,v 1.9 2005/02/22 22:23:08 adamdunkels Exp $
  */

 #include "contiki.h"
 #include "ircc.h"

 #include "irc-conf.h"

 #include "ircc-strings.h"

 #include "petsciiconv.h"

 #include <string.h>

 #define PORT 6667

 #define SEND_STRING(s, str) PSOCK_SEND(s, str, strlen(str))

 #define ISO_space 0x20
 #define ISO_bang  0x21
 #define ISO_at    0x40
 #define ISO_cr    0x0d
 #define ISO_nl    0x0a
 #define ISO_colon 0x3a
 #define ISO_O     0x4f

 enum {
   COMMAND_NONE,
   COMMAND_JOIN,
   COMMAND_PART,
   COMMAND_MSG,
   COMMAND_ACTIONMSG,
   COMMAND_LIST,
   COMMAND_QUIT
 };

 /*---------------------------------------------------------------------------*/
 void
 ircc_init(void)
 {

 }
 /*---------------------------------------------------------------------------*/
 static char *
 copystr(char *dest, const char *src, int n)
 {
   int len;

   len = strlen(src);
   strncpy(dest, src, n);

   if(len > n) {
     return dest + n;
   } else {
     return dest + len;
   }
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(setup_connection(struct ircc_state *s))
 {
   char *ptr;


   PSOCK_BEGIN(&s->s);

   ptr = s->outputbuf;
   ptr = copystr(ptr, ircc_strings_nick, sizeof(s->outputbuf));
   ptr = copystr(ptr, s->nick, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_crnl_user, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, s->nick, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_contiki, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, s->server, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_colon_contiki, sizeof(s->outputbuf) - (ptr - s->outputbuf));

   SEND_STRING(&s->s, s->outputbuf);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(join_channel(struct ircc_state *s))
 {
   PSOCK_BEGIN(&s->s);

   SEND_STRING(&s->s, ircc_strings_join);
   SEND_STRING(&s->s, s->channel);
   SEND_STRING(&s->s, ircc_strings_crnl);

   ircc_sent(s);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(part_channel(struct ircc_state *s))
 {
   PSOCK_BEGIN(&s->s);

   SEND_STRING(&s->s, ircc_strings_part);
   SEND_STRING(&s->s, s->channel);
   SEND_STRING(&s->s, ircc_strings_crnl);

   ircc_sent(s);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(list_channel(struct ircc_state *s))
 {
   PSOCK_BEGIN(&s->s);

   SEND_STRING(&s->s, ircc_strings_list);
   SEND_STRING(&s->s, s->channel);
   SEND_STRING(&s->s, ircc_strings_crnl);

   ircc_sent(s);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(send_message(struct ircc_state *s))
 {
   char *ptr;

   PSOCK_BEGIN(&s->s);

   ptr = s->outputbuf;
   ptr = copystr(ptr, ircc_strings_privmsg, sizeof(s->outputbuf));
   ptr = copystr(ptr, s->channel, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_colon, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, s->msg, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_crnl, sizeof(s->outputbuf) - (ptr - s->outputbuf));

   SEND_STRING(&s->s, s->outputbuf);

   ircc_sent(s);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(send_actionmessage(struct ircc_state *s))
 {
   char *ptr;

   PSOCK_BEGIN(&s->s);

   ptr = s->outputbuf;
   ptr = copystr(ptr, ircc_strings_privmsg, sizeof(s->outputbuf));
   ptr = copystr(ptr, s->channel, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_colon, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_action, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, s->msg, sizeof(s->outputbuf) - (ptr - s->outputbuf));
   ptr = copystr(ptr, ircc_strings_ctcpcrnl, sizeof(s->outputbuf) - (ptr - s->outputbuf));


   SEND_STRING(&s->s, s->outputbuf);

   ircc_sent(s);

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 struct parse_result {
   char *msg;

   char *user;
   char *host;
   char *name;
   char *command;
   char *middle;
   char *trailing;
 };
 static struct parse_result r;
 static void
 parse_whitespace(void)
 {
   while(*r.msg == ISO_space) ++r.msg;
 }
 static void
 parse_word(void)
 {
   char *ptr;
   ptr = strchr(r.msg, ISO_space);
   if(ptr != NULL) {
     r.msg = ptr;
   }
 }
 static void
 parse_user(void)
 {
   parse_whitespace();
   r.user = r.msg;
   parse_word();
   *r.msg = 0;
   ++r.msg;
 }
 static void
 parse_host(void)
 {
   parse_whitespace();
   r.host = r.msg;
   parse_word();
   *r.msg = 0;
   ++r.msg;
 }

 static void
 parse_name(void)
 {
   parse_whitespace();
   r.name = r.msg;
   parse_word();
   *r.msg = 0;
   ++r.msg;
 }

 static void
 parse_prefix(void)
 {
   parse_name();
   if(*r.msg == ISO_bang) {
     ++r.msg;
     parse_user();
   }
   if(*r.msg == ISO_at) {
     ++r.msg;
     parse_host();
   }
 }

 static void
 parse_command(void)
 {
   parse_whitespace();
   r.command = r.msg;
   parse_word();
   *r.msg = 0;
   ++r.msg;
 }

 /*static void
 parse_trailing(void)
 {
   r.trailing = r.msg;
   while(*r.msg != 0 && *r.msg != ISO_cr && *r.msg != ISO_nl) ++r.msg;
   *r.msg = 0;
   ++r.msg;
 }*/

 static void
 parse_params(void)
 {
   char *ptr;

   parse_whitespace();
   ptr = strchr(r.msg, ISO_colon);
   if(ptr != NULL) {
     r.trailing = ptr + 1;
     ptr = strchr(ptr, ISO_cr);
     if(ptr != NULL) {
       *ptr = 0;
     }
   }
 }

 static void
 parse(char *msg, struct parse_result *dummy)
 {
   r.msg = msg;
   if(*r.msg == ISO_cr || *r.msg == ISO_nl) {
     return;
   }
   if(*r.msg == ISO_colon) {
     ++r.msg;
     parse_prefix();
   }

   parse_command();
   parse_params();

   /*  printf("user %s host %s name %s command %s middle %s trailing %s\n",
       r.user, r.host, r.name, r.command, r.middle, r.trailing);*/
 }

 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(handle_input(struct ircc_state *s))
 {
   char *ptr;
   /*  struct parse_result r;*/

   PSOCK_BEGIN(&s->s);

   PSOCK_READTO(&s->s, ISO_nl);

   if(PSOCK_DATALEN(&s->s) > 0) {

     s->inputbuf[PSOCK_DATALEN(&s->s)] = 0;

     if(strncmp(s->inputbuf, ircc_strings_ping, 5) == 0) {
       strncpy(s->outputbuf, s->inputbuf, sizeof(s->outputbuf));

       /* Turn "PING" into "PONG" */
       s->outputbuf[1] = ISO_O;
       SEND_STRING(&s->s, s->outputbuf);
     } else {

       memset(&r, 0, sizeof(r));

       parse(s->inputbuf, &r);

       if(r.name != NULL) {
 	ptr = strchr(r.name, ISO_bang);
 	if(ptr != NULL) {
 	  *ptr = 0;
 	}
       }

       if(r.command != NULL && strncmp(r.command, ircc_strings_join, 4) == 0) {
 	ircc_text_output(s, "Joined channel", r.name);
       } else if(r.command != NULL && strncmp(r.command, ircc_strings_part, 4) == 0) {
 	ircc_text_output(s, "Left channel", r.name);
       } else if(r.trailing != NULL) {
 	if(strncmp(r.trailing, ircc_strings_action,
 		   strlen(ircc_strings_action)) == 0) {
 	  ptr = strchr(&r.trailing[1], 1);
 	  if(ptr != NULL) {
 	    *ptr = 0;
 	  }
 	  ptr = &r.trailing[strlen(ircc_strings_action)];
 	  petsciiconv_topetscii(r.name, strlen(r.name));
 	  petsciiconv_topetscii(ptr, strlen(ptr));
 	  ircc_text_output(s, r.name, ptr);
 	} else if(strncmp(r.trailing, ircc_strings_version_query,
 			  strlen(ircc_strings_version_query)) == 0) {
 	  if(r.name != NULL) {
 	    strncpy(s->outputbuf, r.name, sizeof(s->outputbuf));
 	    SEND_STRING(&s->s, ircc_strings_notice);
 	    /* user is temporarily stored in outputbuf. */
 	    SEND_STRING(&s->s, s->outputbuf);
 	    SEND_STRING(&s->s, ircc_strings_colon);
 	    SEND_STRING(&s->s, ircc_strings_version);
 	    SEND_STRING(&s->s, ircc_strings_version_string);
 	    SEND_STRING(&s->s, IRC_CONF_SYSTEM_STRING);
 	    SEND_STRING(&s->s, ircc_strings_ctcpcrnl);
 	  }
 	} else {
 	  petsciiconv_topetscii(r.name, strlen(r.name));
 	  petsciiconv_topetscii(r.trailing, strlen(r.trailing));
 	  ircc_text_output(s, r.name, r.trailing);
 	}
       }
     }
   }

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(data_or_command(struct ircc_state *s))
 {
   PSOCK_BEGIN(&s->s);

   PSOCK_WAIT_UNTIL(&s->s, PSOCK_NEWDATA(&s->s) ||
 		    (s->command != COMMAND_NONE));

   PSOCK_END(&s->s);
 }
 /*---------------------------------------------------------------------------*/
 static
 PT_THREAD(handle_connection(struct ircc_state *s))
 {
   PT_BEGIN(&s->pt);

   PSOCK_INIT(&s->s, s->inputbuf, sizeof(s->inputbuf) - 1);

   PT_WAIT_THREAD(&s->pt, setup_connection(s));

   while(1) {

     PT_WAIT_UNTIL(&s->pt, data_or_command(s));

     if(PSOCK_NEWDATA(&s->s)) {
       PT_WAIT_THREAD(&s->pt, handle_input(s));
     }

     switch(s->command) {
     case COMMAND_JOIN:
       s->command = COMMAND_NONE;
       PT_WAIT_THREAD(&s->pt, join_channel(s));
       break;
     case COMMAND_PART:
       s->command = COMMAND_NONE;
       PT_WAIT_THREAD(&s->pt, part_channel(s));
       break;
     case COMMAND_MSG:
       s->command = COMMAND_NONE;
       PT_WAIT_THREAD(&s->pt, send_message(s));
       break;
     case COMMAND_ACTIONMSG:
       s->command = COMMAND_NONE;
       PT_WAIT_THREAD(&s->pt, send_actionmessage(s));
       break;
     case COMMAND_LIST:
       s->command = COMMAND_NONE;
       PT_WAIT_THREAD(&s->pt, list_channel(s));
       break;
     case COMMAND_QUIT:
       s->command = COMMAND_NONE;
       tcp_markconn(uip_conn, NULL);
       PSOCK_CLOSE(&s->s);
       ek_post(EK_PROC_ID(EK_CURRENT()), EK_EVENT_REQUEST_EXIT, NULL);
       PT_EXIT(&s->pt);
       break;
     default:
       break;
     }
   }

   PT_END(&s->pt);
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_appcall(void *s)
 {
   if(uip_closed() || uip_aborted() || uip_timedout()) {
     ircc_closed(s);
   } else if(uip_connected()) {
     ircc_connected(s);
     PT_INIT(&((struct ircc_state *)s)->pt);
     memset(((struct ircc_state *)s)->channel, 0,
 	   sizeof(((struct ircc_state *)s)->channel));
     ((struct ircc_state *)s)->command = COMMAND_NONE;
     handle_connection(s);
   } else if(s != NULL) {
     handle_connection(s);
   }
 }
 /*---------------------------------------------------------------------------*/
 struct ircc_state *
 ircc_connect(struct ircc_state *s, char *servername, u16_t *ipaddr,
 	     char *nick)
 {
   s->conn = tcp_connect(ipaddr, HTONS(PORT), s);
   if(s->conn == NULL) {
     return NULL;
   }
   s->server = servername;
   s->nick = nick;
   return s;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_list(struct ircc_state *s)
 {
   s->command = COMMAND_LIST;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_join(struct ircc_state *s, char *channel)
 {
   strncpy(s->channel, channel, sizeof(s->channel));
   s->command = COMMAND_JOIN;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_part(struct ircc_state *s)
 {
   s->command = COMMAND_PART;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_quit(struct ircc_state *s)
 {
   s->command = COMMAND_QUIT;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_msg(struct ircc_state *s, char *msg)
 {
   s->msg = msg;
   s->command = COMMAND_MSG;
 }
 /*---------------------------------------------------------------------------*/
 void
 ircc_actionmsg(struct ircc_state *s, char *msg)
 {
   s->msg = msg;
   s->command = COMMAND_ACTIONMSG;
 }
 /*---------------------------------------------------------------------------*/
	/*
	* Copyright (c) 2004, Adam Dunkels.
	* All rights reserved.
	*
	* Redistribution and use in source and binary forms, with or without
	* modification, are permitted provided that the following conditions
	* are met:
	* 1. Redistributions of source code must retain the above copyright
	* notice, this list of conditions and the following disclaimer.
	* 2. Redistributions in binary form must reproduce the above copyright
	* notice, this list of conditions and the following disclaimer in the
	* documentation and/or other materials provided with the distribution.
	* 3. Neither the name of the Institute nor the names of its contributors
	* may be used to endorse or promote products derived from this software
	* without specific prior written permission.
	*
	* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	* SUCH DAMAGE.
	*
	* This file is part of the Contiki operating system.
	*
	* Author: Adam Dunkels <adam@sics.se>
	*
	* $Id: ircc.c,v 1.9 2005/02/22 22:23:08 adamdunkels Exp $
	*/

	#include "contiki.h"
	#include "ircc.h"

	#include "irc-conf.h"

	#include "ircc-strings.h"

	#include "petsciiconv.h"

	#include <string.h>

	#define PORT 6667

	#define SEND_STRING(s, str) PSOCK_SEND(s, str, strlen(str))

	#define ISO_space 0x20
	#define ISO_bang 0x21
	#define ISO_at 0x40
	#define ISO_cr 0x0d
	#define ISO_nl 0x0a
	#define ISO_colon 0x3a
	#define ISO_O 0x4f

	enum {
	COMMAND_NONE,
	COMMAND_JOIN,
	COMMAND_PART,
	COMMAND_MSG,
	COMMAND_ACTIONMSG,
	COMMAND_LIST,
	COMMAND_QUIT
	};

	/---------------------------------------------------------------------------/
	void
	ircc_init(void)
	{

	}
	/---------------------------------------------------------------------------/
	static char *
	copystr(char dest, const char src, int n)
	{
	int len;

	len = strlen(src);
	strncpy(dest, src, n);

	if(len > n) {
	return dest + n;
	} else {
	return dest + len;
	}
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(setup_connection(struct ircc_state *s))
	{
	char *ptr;


	PSOCK_BEGIN(&s->s);

	ptr = s->outputbuf;
	ptr = copystr(ptr, ircc_strings_nick, sizeof(s->outputbuf));
	ptr = copystr(ptr, s->nick, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_crnl_user, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, s->nick, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_contiki, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, s->server, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_colon_contiki, sizeof(s->outputbuf) - (ptr - s->outputbuf));

	SEND_STRING(&s->s, s->outputbuf);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(join_channel(struct ircc_state *s))
	{
	PSOCK_BEGIN(&s->s);

	SEND_STRING(&s->s, ircc_strings_join);
	SEND_STRING(&s->s, s->channel);
	SEND_STRING(&s->s, ircc_strings_crnl);

	ircc_sent(s);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(part_channel(struct ircc_state *s))
	{
	PSOCK_BEGIN(&s->s);

	SEND_STRING(&s->s, ircc_strings_part);
	SEND_STRING(&s->s, s->channel);
	SEND_STRING(&s->s, ircc_strings_crnl);

	ircc_sent(s);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(list_channel(struct ircc_state *s))
	{
	PSOCK_BEGIN(&s->s);

	SEND_STRING(&s->s, ircc_strings_list);
	SEND_STRING(&s->s, s->channel);
	SEND_STRING(&s->s, ircc_strings_crnl);

	ircc_sent(s);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(send_message(struct ircc_state *s))
	{
	char *ptr;

	PSOCK_BEGIN(&s->s);

	ptr = s->outputbuf;
	ptr = copystr(ptr, ircc_strings_privmsg, sizeof(s->outputbuf));
	ptr = copystr(ptr, s->channel, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_colon, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, s->msg, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_crnl, sizeof(s->outputbuf) - (ptr - s->outputbuf));

	SEND_STRING(&s->s, s->outputbuf);

	ircc_sent(s);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(send_actionmessage(struct ircc_state *s))
	{
	char *ptr;

	PSOCK_BEGIN(&s->s);

	ptr = s->outputbuf;
	ptr = copystr(ptr, ircc_strings_privmsg, sizeof(s->outputbuf));
	ptr = copystr(ptr, s->channel, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_colon, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_action, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, s->msg, sizeof(s->outputbuf) - (ptr - s->outputbuf));
	ptr = copystr(ptr, ircc_strings_ctcpcrnl, sizeof(s->outputbuf) - (ptr - s->outputbuf));


	SEND_STRING(&s->s, s->outputbuf);

	ircc_sent(s);

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	struct parse_result {
	char *msg;

	char *user;
	char *host;
	char *name;
	char *command;
	char *middle;
	char *trailing;
	};
	static struct parse_result r;
	static void
	parse_whitespace(void)
	{
	while(*r.msg == ISO_space) ++r.msg;
	}
	static void
	parse_word(void)
	{
	char *ptr;
	ptr = strchr(r.msg, ISO_space);
	if(ptr != NULL) {
	r.msg = ptr;
	}
	}
	static void
	parse_user(void)
	{
	parse_whitespace();
	r.user = r.msg;
	parse_word();
	*r.msg = 0;
	++r.msg;
	}
	static void
	parse_host(void)
	{
	parse_whitespace();
	r.host = r.msg;
	parse_word();
	*r.msg = 0;
	++r.msg;
	}

	static void
	parse_name(void)
	{
	parse_whitespace();
	r.name = r.msg;
	parse_word();
	*r.msg = 0;
	++r.msg;
	}

	static void
	parse_prefix(void)
	{
	parse_name();
	if(*r.msg == ISO_bang) {
	++r.msg;
	parse_user();
	}
	if(*r.msg == ISO_at) {
	++r.msg;
	parse_host();
	}
	}

	static void
	parse_command(void)
	{
	parse_whitespace();
	r.command = r.msg;
	parse_word();
	*r.msg = 0;
	++r.msg;
	}

	/*static void
	parse_trailing(void)
	{
	r.trailing = r.msg;
	while(r.msg != 0 && r.msg != ISO_cr && *r.msg != ISO_nl) ++r.msg;
	*r.msg = 0;
	++r.msg;
	}*/

	static void
	parse_params(void)
	{
	char *ptr;

	parse_whitespace();
	ptr = strchr(r.msg, ISO_colon);
	if(ptr != NULL) {
	r.trailing = ptr + 1;
	ptr = strchr(ptr, ISO_cr);
	if(ptr != NULL) {
	*ptr = 0;
	}
	}
	}

	static void
	parse(char msg, struct parse_result dummy)
	{
	r.msg = msg;
	if(r.msg == ISO_cr \|\| r.msg == ISO_nl) {
	return;
	}
	if(*r.msg == ISO_colon) {
	++r.msg;
	parse_prefix();
	}

	parse_command();
	parse_params();

	/* printf("user %s host %s name %s command %s middle %s trailing %s\n",
	r.user, r.host, r.name, r.command, r.middle, r.trailing);*/
	}

	/---------------------------------------------------------------------------/
	static
	PT_THREAD(handle_input(struct ircc_state *s))
	{
	char *ptr;
	/* struct parse_result r;*/

	PSOCK_BEGIN(&s->s);

	PSOCK_READTO(&s->s, ISO_nl);

	if(PSOCK_DATALEN(&s->s) > 0) {

	s->inputbuf[PSOCK_DATALEN(&s->s)] = 0;

	if(strncmp(s->inputbuf, ircc_strings_ping, 5) == 0) {
	strncpy(s->outputbuf, s->inputbuf, sizeof(s->outputbuf));

	/* Turn "PING" into "PONG" */
	s->outputbuf[1] = ISO_O;
	SEND_STRING(&s->s, s->outputbuf);
	} else {

	memset(&r, 0, sizeof(r));

	parse(s->inputbuf, &r);

	if(r.name != NULL) {
	ptr = strchr(r.name, ISO_bang);
	if(ptr != NULL) {
	*ptr = 0;
	}
	}

	if(r.command != NULL && strncmp(r.command, ircc_strings_join, 4) == 0) {
	ircc_text_output(s, "Joined channel", r.name);
	} else if(r.command != NULL && strncmp(r.command, ircc_strings_part, 4) == 0) {
	ircc_text_output(s, "Left channel", r.name);
	} else if(r.trailing != NULL) {
	if(strncmp(r.trailing, ircc_strings_action,
	strlen(ircc_strings_action)) == 0) {
	ptr = strchr(&r.trailing[1], 1);
	if(ptr != NULL) {
	*ptr = 0;
	}
	ptr = &r.trailing[strlen(ircc_strings_action)];
	petsciiconv_topetscii(r.name, strlen(r.name));
	petsciiconv_topetscii(ptr, strlen(ptr));
	ircc_text_output(s, r.name, ptr);
	} else if(strncmp(r.trailing, ircc_strings_version_query,
	strlen(ircc_strings_version_query)) == 0) {
	if(r.name != NULL) {
	strncpy(s->outputbuf, r.name, sizeof(s->outputbuf));
	SEND_STRING(&s->s, ircc_strings_notice);
	/* user is temporarily stored in outputbuf. */
	SEND_STRING(&s->s, s->outputbuf);
	SEND_STRING(&s->s, ircc_strings_colon);
	SEND_STRING(&s->s, ircc_strings_version);
	SEND_STRING(&s->s, ircc_strings_version_string);
	SEND_STRING(&s->s, IRC_CONF_SYSTEM_STRING);
	SEND_STRING(&s->s, ircc_strings_ctcpcrnl);
	}
	} else {
	petsciiconv_topetscii(r.name, strlen(r.name));
	petsciiconv_topetscii(r.trailing, strlen(r.trailing));
	ircc_text_output(s, r.name, r.trailing);
	}
	}
	}
	}

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(data_or_command(struct ircc_state *s))
	{
	PSOCK_BEGIN(&s->s);

	PSOCK_WAIT_UNTIL(&s->s, PSOCK_NEWDATA(&s->s) \|\|
	(s->command != COMMAND_NONE));

	PSOCK_END(&s->s);
	}
	/---------------------------------------------------------------------------/
	static
	PT_THREAD(handle_connection(struct ircc_state *s))
	{
	PT_BEGIN(&s->pt);

	PSOCK_INIT(&s->s, s->inputbuf, sizeof(s->inputbuf) - 1);

	PT_WAIT_THREAD(&s->pt, setup_connection(s));

	while(1) {

	PT_WAIT_UNTIL(&s->pt, data_or_command(s));

	if(PSOCK_NEWDATA(&s->s)) {
	PT_WAIT_THREAD(&s->pt, handle_input(s));
	}

	switch(s->command) {
	case COMMAND_JOIN:
	s->command = COMMAND_NONE;
	PT_WAIT_THREAD(&s->pt, join_channel(s));
	break;
	case COMMAND_PART:
	s->command = COMMAND_NONE;
	PT_WAIT_THREAD(&s->pt, part_channel(s));
	break;
	case COMMAND_MSG:
	s->command = COMMAND_NONE;
	PT_WAIT_THREAD(&s->pt, send_message(s));
	break;
	case COMMAND_ACTIONMSG:
	s->command = COMMAND_NONE;
	PT_WAIT_THREAD(&s->pt, send_actionmessage(s));
	break;
	case COMMAND_LIST:
	s->command = COMMAND_NONE;
	PT_WAIT_THREAD(&s->pt, list_channel(s));
	break;
	case COMMAND_QUIT:
	s->command = COMMAND_NONE;
	tcp_markconn(uip_conn, NULL);
	PSOCK_CLOSE(&s->s);
	ek_post(EK_PROC_ID(EK_CURRENT()), EK_EVENT_REQUEST_EXIT, NULL);
	PT_EXIT(&s->pt);
	break;
	default:
	break;
	}
	}

	PT_END(&s->pt);
	}
	/---------------------------------------------------------------------------/
	void
	ircc_appcall(void *s)
	{
	if(uip_closed() \|\| uip_aborted() \|\| uip_timedout()) {
	ircc_closed(s);
	} else if(uip_connected()) {
	ircc_connected(s);
	PT_INIT(&((struct ircc_state *)s)->pt);
	memset(((struct ircc_state *)s)->channel, 0,
	sizeof(((struct ircc_state *)s)->channel));
	((struct ircc_state *)s)->command = COMMAND_NONE;
	handle_connection(s);
	} else if(s != NULL) {
	handle_connection(s);
	}
	}
	/---------------------------------------------------------------------------/
	struct ircc_state *
	ircc_connect(struct ircc_state s, char servername, u16_t *ipaddr,
	char *nick)
	{
	s->conn = tcp_connect(ipaddr, HTONS(PORT), s);
	if(s->conn == NULL) {
	return NULL;
	}
	s->server = servername;
	s->nick = nick;
	return s;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_list(struct ircc_state *s)
	{
	s->command = COMMAND_LIST;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_join(struct ircc_state s, char channel)
	{
	strncpy(s->channel, channel, sizeof(s->channel));
	s->command = COMMAND_JOIN;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_part(struct ircc_state *s)
	{
	s->command = COMMAND_PART;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_quit(struct ircc_state *s)
	{
	s->command = COMMAND_QUIT;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_msg(struct ircc_state s, char msg)
	{
	s->msg = msg;
	s->command = COMMAND_MSG;
	}
	/---------------------------------------------------------------------------/
	void
	ircc_actionmsg(struct ircc_state s, char msg)
	{
	s->msg = msg;
	s->command = COMMAND_ACTIONMSG;
	}
	/---------------------------------------------------------------------------/