[Tävling] Skapa en simpel IRC-bot i valfritt språk

send_command(NICK nickname)
send_command(USER nickname foo bar :nickname)
stuff = recv_command()

if stuff.command == "PING" then
    send_command(PONG :stuff.message)
endif

import sys
import socket
import re

recv_size = 512 

# OptionParser makes it easier to use Unix-style command-line
# arguments, and as an added bonus it handles the default
# values for us so we don't have to muck around setting those up.
from optparse import OptionParser
parser = OptionParser()
parser.add_option("-s", "--servername",
        dest = "hostname",
        help = "connect to HOSTNAME",
        metavar = "HOSTNAME",
        default = "irc.quakenet.org")
parser.add_option("-p","--port",
        dest = "port",
        help = "connect on PORT",
        metavar = "PORT",
        default = "6668")
parser.add_option("-n", "--nickname",
        dest = "nickname",
        help = "connect using NICK",
        metavar = "NICK",
        default = "filobot")
parser.add_option("-c", "--channels",
        dest = "channels",
        help = "join CHANNELS. (comma-separated list. No #!)",
        metavar = "CHANNELS",
        default = "filotest")
parser.add_option("-m","--masters",
        dest = "masters",
        help = "empower MASTERS. (comma-separated list of nicks.)",
        metavar = "MASTERS",
        default = "kungtotte")
(o, args) = parser.parse_args()

def send_cmd(sock, str):
    sock.send(str + "\r\n")


def send_msg(sock, target, msg):
    send_cmd(sock, "PRIVMSG %s :%s" % (target, msg))


def extract_nick(pre):
    start = 1 # 1 is the first char of the nick. 
    end = pre.find("!")
    return  pre[start:end]


def parse_message(d):
    # Credits to mOREc for this regexp. Pretty damn nifty!
    p = r'^(:([^  ]+))?[   ]*([^  ]+)[  ]+:?([^  ]*)[   ]*:?(.*)$'
    r = re.search(p, d, re.M)
    if r:
        prefix  = r.group(1)
        command = r.group(3)
        arg     = r.group(4)
        args    = r.group(5)
        return (prefix, command, arg, args)
    else:
        return ("","","","")


def handle_private_message(nick, args):
    words = args.split()
    masters = o.masters.split()
    if nick in masters:
        if words[0] == "nick":
            send_cmd(s, "NICK %s" % words[1])
            o.nickname = words[1]
        elif words[0] == "addmaster":
            send_msg(s, nick, "Added %s to list" % words[1])
            o.masters = o.masters + "," + words[1]
        elif words[0] == "quit":
            s.close()
            sys.exit(1)
        elif words[0] == "say":
            send_msg(s, words[1], ' '.join(words[2:]))


def handle_public_message(nick, chan, args):
    # Left here if we want to put in triggers
    return


try:
    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((o.hostname, int(o.port)))
except socket.error, (value,message):
    if s:
        s.close()
    print "Could not connect to IRC server: " + message
    sys.exit(1)

# Register with the server. This works fine on QuakeNet, and I assume
# other networks too.
send_cmd(s, "NICK " + o.nickname)
send_cmd(s, "USER %s foo bar :%s" % (o.nickname, o.nickname))

while True:
    d = s.recv(recv_size)
    (prefix, cmd, arg, args)  = parse_message(d)
    if prefix:
        nick = extract_nick(prefix)
    
    # On quakenet this shows are are connected.
    # I have NO idea how other standards compliant networks handle
    # this. Need to investigate.
    if cmd == "001":
        channels = o.channels.split(',')
        for c in channels:
            send_cmd(s, "JOIN #%s" % c)
    
    if cmd == "PING":
        send_cmd(s, "PONG :%s" % arg)
    elif cmd == "INVITE":
        chan = args.split()[0]
        send_cmd(s, "JOIN %s" % chan)
    elif cmd == "PRIVMSG":
        if arg == o.nickname:
            handle_private_message(nick, args)
        else:
            handle_public_message(nick, arg, args)

#include <stdio.h>
#include <errno.h>
#include <netdb.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>

#define SERVER   "irc.freenode.org"
#define PORT     6667
#define CHANNEL  "#bot_test"
#define NICKNAME "easy_cbot"
#define USERNAME "easy_c_bot"
#define REALNAME "Easy C IRC-bot"

#define BUFSIZE 512

int send_command(int sock, char *data) {
	int status;

	sprintf(data, "%s\r\n", data);

	status = send(sock, data, strlen(data), 0);

	if (status == -1) {
		perror("send");
		exit(1);
	}
	
	return status;
}

char *get_nickname(char *string) {
	int position;
	char tmp[15];

	++string;

	for (position = 0; string[position] != '!'; position++);

	return strncpy(tmp, string, position);
}

char *get_message(char *string) {
	return ++string;
}

int main(int argc, char *argv[]) {
	int sockfd, numbytes;
	char buf[BUFSIZE], data[BUFSIZE], *prefix, *command, *arg, *args;
	struct hostent *he;
	struct sockaddr_in addr;

	prefix  = NULL;
	command = NULL;
	arg     = NULL;
	args    = NULL;

	he = gethostbyname(SERVER);

	sockfd = socket(PF_INET, SOCK_STREAM, 0);

	addr.sin_family = AF_INET;
	addr.sin_port   = htons(PORT);
	addr.sin_addr   = *((struct in_addr *)he->h_addr);
	memset(&(addr.sin_zero), '\0', 8);

	connect(sockfd, (struct sockaddr *)&addr, sizeof(struct sockaddr));

	sprintf(data, "NICK %s", NICKNAME);
	send_command(sockfd, data);
	sprintf(data, "USER %s aoeu htns :%s", USERNAME, REALNAME);
	send_command(sockfd, data);

	while (1) {
		numbytes = recv(sockfd, buf, BUFSIZE - 1, 0);

		buf[numbytes] = '\0';

		if (strstr(buf, "004")) {
			if (strstr(buf, "433")) {
				printf("Nickname already taken.\n");
				exit(1);
			} else
				break;
		}
	}

	sprintf(data, "JOIN %s", CHANNEL);
	send_command(sockfd, data);

	while (1) {
		prefix  = NULL;
		command = NULL;
		arg     = NULL;
		args    = NULL;

		numbytes = recv(sockfd, buf, BUFSIZE - 1, 0)

		buf[numbytes] = '\0';

		prefix  = strtok(buf, " ");
		command = strtok(NULL, " ");
		arg     = strtok(NULL, " ");
		args    = strtok(NULL, "");

		if (command != NULL && !strcmp(command, "PRIVMSG"))
			printf("[MSG] %s> %s", get_nickname(prefix), get_message(args));
		else if (command != NULL && !strcmp(command, "NOTICE"))
			printf("[NOTICE] %s> %s", get_nickname(prefix), get_message(args));
		else if (command != NULL && !strcmp(command, "JOIN"))
			printf("[JOIN] %s -> %s", get_nickname(prefix), get_message(arg));
		else if (prefix != NULL && !strcmp(prefix, "PING")) {
			sprintf(data, "PONG %s", command);
			send_command(sockfd, data);
			printf("PING? PONG!\n");
		}
		else
			printf("[%s] %s {%s} (%s)\n", command, prefix, arg, args);

	}

	close(sockfd);

	return 0;
}

<?php
	class ircBot
	{
		protected $socket;

		public $server;
		public $port;
		public $password;

		public $nickname;
		public $username;
		public $login_type;
		public $real_name;
		public $channel;

		function start_bot()
		{
			$this -> socket = fsockopen($this -> server, $this -> port);
			if(!$this -> socket)
			{
				Die('Kunde inte ansluta');
			}
			else
			{
				if(strlen($this -> password) > 0)
				{
					$this -> send_data('PASS ' . $this -> password);
				}

				$this -> send_data('NICK ' . $this -> nickname);
				$this -> send_data('USER ' . $this -> username . ' ' . $this -> login_type . ' :' . $this -> real_name);
				
				$this -> send_data('JOIN ' . $this -> channel);

				while($this -> socket)
				{
					echo $this -> read_data($this -> socket);
				}


			}
		}
		
		function send_data($message)
		{
			fputs($this -> socket, $message . "\r\n", 512);
		}

		function read_ping($in)
		{
			if(strpos($in, 'PING: ') !== FALSE)
			{
				$this -> send_data('PONG: ' . substr($in, 6));
			}
		}

		function read_data($data)
		{
			$in = fgets($data, 4096);
			$this -> read_ping($in);

			return $in;
		}
	}

	$irc = New ircBot();

	$irc -> server = 'irc.freenode.net';
	$irc -> port = '6667';
	$irc -> password = '';

	$irc -> nickname = 'Kejsarns-bot';
	$irc -> username = 'Kejsarns-bot';
	$irc -> login_type = '* 0';
	$irc -> real_name = 'The Devine bot';
	$irc -> channel = '#kejsarn-leker';

	$irc -> start_bot();
?>

require 'socket'
sock = TCPSocket.new("port80.se.quakenet.org", "6667")

sock.puts("NICK serpbot")
sock.puts("USER a a a :a")

connected = false

while (line = sock.gets)
  if (line.index('PING') == 0)
    line[1] = 'O'
    sock.puts(line)
    if (!connected)
      sock.puts("JOIN #sweclockers")
      sock.puts("PRIVMSG #sweclockers :hej :D")
      connected = true
    end
  end
end