# -*- coding: utf-8 -*-
# Copyright (C) 2011 godric <godric@0x3f.fr>
# License: WTFPL
#
# Changelog
# v1.1
# + re-implemented state change
# + changed pattern and color in nicklist
SCRIPT_NAME = 'weenetsoul'
SCRIPT_AUTHOR = 'godric <godric@0x3f.fr>'
SCRIPT_VERSION = '1.1'
SCRIPT_LICENSE = 'WTFPL'
SCRIPT_DESC = 'Netsoul protocol for WeeChat'
import weechat
import time, socket, hashlib, urllib, datetime, re
########################################
# Netsoul network functions
########################################
class weeNSUser :
def __init__(self, login, data = '', location = '', group = '', state = '', state_time = 0, machtype = '',
ip = '', connection_time = 0, lastseen_time = 0, user_trust = 0, client_trust = 0, fd = '') :
self.login = login
self.fd = fd
self.data = data
self.location = location
self.group = group
self.state = state
self.state_time = int(state_time)
self.machtype = machtype
self.ip = ip
self.connection_time = int(connection_time)
self.lastseen_time = int(lastseen_time)
self.user_trust = int(user_trust)
self.client_trust = int(client_trust)
self.nick = None
def prnt(self, buffer = '', prefix = '') :
hcolor = weechat.color('separator')
ncolor = weechat.color('chat_nick')
prefix = prefix+hcolor
weechat.prnt(buffer, "%s%s=============== %s[%s] (%s) %s===============\n" % (prefix, hcolor, ncolor, self.login, self.fd, hcolor))
weechat.prnt(buffer, '%s Host . . . . . . . . : %s\n' % (prefix, self.ip))
weechat.prnt(buffer, "%s Machine type . . . . : %s\n" % (prefix, self.machtype))
weechat.prnt(buffer, "%s Group. . . . . . . . : %s\n" % (prefix, self.group))
weechat.prnt(buffer, "%s State. . . . . . . . : %s\n" % (prefix, self.state))
weechat.prnt(buffer, "%s Data . . . . . . . . : %s\n" % (prefix, self.data))
weechat.prnt(buffer, "%s Location . . . . . . : %s\n" % (prefix, self.location))
weechat.prnt(buffer, "%s Connected at . . . . : %s\n" % (prefix, datetime.datetime.fromtimestamp(self.connection_time).strftime('%d/%m/%Y %H:%M:%S')))
weechat.prnt(buffer, "%s Last Activity. . . . : %s\n" % (prefix, datetime.datetime.fromtimestamp(self.lastseen_time).strftime('%d/%m/%Y %H:%M:%S')))
weechat.prnt(buffer, "%s Last status change . : %s\n" % (prefix, datetime.datetime.fromtimestamp(self.state_time).strftime('%d/%m/%Y %H:%M:%S')))
weechat.prnt(buffer, "%s Trust (User/client). : (%d/%d)\n" % (prefix, self.user_trust, self.client_trust))
weechat.prnt(buffer, "%s%s==============================================" % (prefix, hcolor))
class weeNSChat :
def __init__(self, server, login = None, fd = None) :
self.server = server
self.login = login
self.fd = fd
self.buffer = weechat.buffer_new('Netsoul.temp', 'weeNS_buffer_input_cb', '', 'weeNS_buffer_close_cb', '')
weechat.buffer_set(self.buffer, "display", "auto")
self.updateBuffer(login)
self.server.chats.append(self)
def updateBuffer(self, login) :
self.login = login
fd = self.fd or '*'
login = self.login or 'unknown'
weechat.buffer_set(self.buffer, "title", 'Netsoul chat with %s on %s' % (login, fd))
weechat.buffer_set(self.buffer, 'name', 'Netsoul.%s:%s' % (login, fd))
weechat.buffer_set(self.buffer, 'short_name', 'Netsoul.%s:%s' % (login, fd))
def recv(self, login, message) :
if login != self.login :
self.updateBuffer(login)
weechat.prnt(self.buffer, '%s%s\t%s' % (weechat.color("chat_nick"), self.login, message))
def send(self, message) :
weechat.prnt(self.buffer, '%s%s\t%s' % (weechat.color("chat_nick_self"), self.server.getOption('login'), message))
recipient = self.login if self.fd is None else ':'+self.fd
self.server._ns_user_cmd_msg_user(recipient, message)
def delete(self) :
if self.buffer is not None :
return weechat.buffer_close(self.buffer)
self.server.chats.remove(self)
class weeNSServer :
def __init__(self) :
global weeNS_server_opt, weeNS_config_file, weeNS_config_server_section
self.buffer = None
self.hook_fd = None
self.socket = None
self.netbuffer = ''
self.chats = []
self.contacts = {}
self.options = {
'host' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'host', 'string', 'Server Host (default: ns-server.epita.fr)', '', 0, 0,
'ns-server.epita.fr', 'ns-server.epita.fr', 0, '', '', '', '', '', ''),
'port' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'port', 'string', 'Server Port (default: 4242)', '', 0, 0,
'4242', '4242', 0, '', '', '', '', '', ''),
'login' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'login', 'string', 'User login (ie: login_x)', '', 0, 0,
'login_x', 'login_x', 0, '', '', '', '', '', ''),
'password' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'password', 'string', 'User password (ie: your SOCKS password)', '', 0, 0,
'xxxxxx', 'xxxxxx', 0, '', '', '', '', '', ''),
'location' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'location', 'string', 'User location (ie: at home)', '', 0, 0,
'-', '-', 0, '', '', '', '', '', ''),
'data' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'data', 'string', 'User data (ie: j\'aime les chips)', '', 0, 0,
'-', '-', 0, '', '', '', '', '', ''),
'contacts' : weechat.config_new_option(weeNS_config_file, weeNS_config_server_section,
'contacts', 'string', 'Comma separated login list (ie: sb,rn)', '', 0, 0,
'', '', 0, '', '', '', '', '', '')}
def getOption(self, opt_name) :
return weechat.config_string(self.options[opt_name])
def getChatByRecipient(self, login = None, fd = None, create = False) :
for chat in self.chats :
if (fd is not None and chat.fd == fd) or (chat.login == login and chat.fd == fd) :
return chat
if create is True :
return weeNSChat(self, login, fd)
return None
def getChatByBuffer(self, buffer) :
for chat in self.chats :
if chat.buffer == buffer :
return chat
return server
def createBuffer(self) :
if self.buffer == None :
self.buffer = weechat.buffer_new('Netsoul', 'weeNS_buffer_input_cb', '', 'weeNS_buffer_close_cb', '')
weechat.buffer_set(self.buffer, "nicklist", "1")
weechat.buffer_set(self.buffer, "nicklist_display_groups", "1")
weechat.buffer_set(self.buffer, "display", "auto")
def connect(self) :
self.createBuffer()
self.disconnect()
weechat.prnt(self.buffer, 'Connecting to %s:%s' % (self.getOption('host'), self.getOption('port')))
for res in socket.getaddrinfo(self.getOption('host'), self.getOption('port'), socket.AF_UNSPEC, socket.SOCK_STREAM, 0, socket.AI_PASSIVE) :
af, socktype, proto, canonname, sa = res
try :
self.socket = socket.socket(af, socktype, proto)
self.socket.connect(sa)
except socket.error, msg:
self.socket = None
continue
break
if self.socket is None :
weechat.prnt(self.buffer, 'Could not connect')
self.hook_fd = weechat.hook_fd(self.socket.fileno(), 1, 0, 0, 'weeNS_hook_fd_cb', '')
def recv(self) :
# while 1337 :
data = self.socket.recv(512)
if len(data) == 0 :
return self.disconnect()
self.netbuffer += data
while "\n" in self.netbuffer :
line, ignored, buffer = self.netbuffer.partition("\n")
index = len(line) + 1
self.netbuffer = self.netbuffer[index:]
weechat.prnt(self.buffer, '%s[%s]' % (
weechat.prefix('join'),
line))
self._ns_parse(line)
def send(self, data) :
weechat.prnt(self.buffer, '%s[%s]' % (weechat.prefix('quit'), data))
self.socket.send('%s\n' % data)
def isConnected(self) :
return (self.socket is not None)
def disconnect(self) :
if self.hook_fd is not None :
weechat.unhook(self.hook_fd)
if self.socket is not None :
self.socket.close()
if self.buffer is not None :
self.contacts = {}
weechat.nicklist_remove_all(self.buffer)
weechat.prnt(self.buffer, '... Disconnected ...')
self.hook_fd = None
self.socket = None
self.contacts = {}
def delete(self) :
for chat in reversed(self.chats) :
chat.delete()
self.disconnect()
if self.buffer is not None :
weechat.buffer_close(self.buffer)
self.buffer = None
for option in self.options.keys():
weechat.config_option_free(option)
def setupNicklist(self) :
contact_list = self.getOption('contacts').replace(' ', '').split(',')
for login in contact_list :
weechat.nicklist_add_group(self.buffer, '', login, 'lightcyan', 1)
self.contacts[login] = {}
self._ns_user_cmd_who('{%s}' % ','.join(contact_list))
self._ns_user_cmd_watch_log_user(','.join(contact_list))
def updateNicklist(self, user, remove = False) :
group = weechat.nicklist_search_group(self.buffer, '', user.login)
if group is not None and user.login in self.contacts :
if user.fd in self.contacts[user.login] :
weechat.nicklist_remove_nick(self.buffer, self.contacts[user.login][user.fd].nick)
del self.contacts[user.login][user.fd]
if remove is False :
user.nick = weechat.nicklist_add_nick(self.buffer, group, ' :%s%s@%s%s' % (user.fd, weechat.color('separator'), weechat.color('default'), user.location), '', '', '', 1)
self.contacts[user.login][user.fd] = user
def _ns_auth_ag(self) :
self.send("auth_ag ext_user none none")
def _ns_ext_user_log(self, secret, ip, port) :
location = urllib.quote(self.getOption('location'))
data = urllib.quote(self.getOption('data'))
crypt = hashlib.md5('%s-%s/%s%s' % (secret, ip, port, self.getOption('password'))).hexdigest()
self.send("ext_user_log %s %s %s %s" % (self.getOption('login'), crypt, location, data))
def _ns_user_cmd_msg_user(self, login, msg) :
msg = unicode(msg, 'utf-8').encode('iso-8859-1')
self.send("user_cmd msg_user %s msg %s" % (login, urllib.quote(msg)))
def _ns_user_cmd_who(self, login) :
self.send("user_cmd who %s" % login)
def _ns_user_cmd_watch_log_user(self, friends) :
self.send("user_cmd watch_log_user {%s}" % friends)
def _ns_state(self, state) :
self.send("state %s:%s" % (state, int(time.time())))
def _ns_parse(self, data) :
arglist = data.split(' ')
if arglist[0] == 'salut' :
self._ns_parse_salut(arglist)
elif arglist[0] == 'ping' :
self._ns_parse_ping(arglist)
elif arglist[0] == 'user_cmd' :
if arglist[3] == 'msg' :
self._ns_parse_user_cmd_msg(arglist)
elif arglist[3] == 'who':
self._ns_parse_user_cmd_who(arglist)
elif arglist[3] == 'login' :
self._ns_parse_user_cmd_login(arglist)
elif arglist[3] == 'logout' :
self._ns_parse_user_cmd_logout(arglist)
elif arglist[3] == 'state' :
self._ns_parse_user_cmd_state(arglist)
def _ns_parse_from(self, str) :
r = re.compile('([0-9]+):user:([0-9]+)/([0-9]+):([_a-z]+)@([0-9.]+):([^ :]+):([^ :]+):([^ :]+)');
match = re.match(r, str)
groups = match.groups()
user = weeNSUser(fd = groups[0], client_trust = groups[1], user_trust = groups[2], login = groups[3],
ip = groups[4], machtype = groups[5], location = groups[6], group = groups[7])
return user
def _ns_parse_salut(self, arglist) :
self._ns_auth_ag()
self._ns_ext_user_log(arglist[2], arglist[3], arglist[4])
self.setupNicklist()
def _ns_parse_ping(self, arglist) :
self.send("ping %s" % arglist[1])
def _ns_parse_user_cmd_msg(self, arglist) :
user = self._ns_parse_from(arglist[1])
msg = urllib.unquote(arglist[4])
msg = unicode(msg, 'iso-8859-1').encode('utf-8')
pchat = self.getChatByRecipient(fd = user.fd)
if pchat is not None :
pchat.recv(user.login, msg)
gchat = self.getChatByRecipient(user.login, create = (pchat is None))
if gchat is not None :
gchat.recv(user.login, msg)
def _ns_parse_user_cmd_who(self, arglist) :
r = re.compile('who ([0-9]+) ([_a-z]+) ([0-9.]+) ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+) ([^ ]+) ([^ ]+) ([^ ]+) ([^ :]+):{0,1}([0-9]+){0,1} ([^ ]+)')
match = re.match(r, ' '.join(arglist[3:]))
if match is not None :
groups = match.groups()
user = weeNSUser(fd = groups[0], login = groups[1], ip = groups[2], connection_time = groups[3], lastseen_time = groups[4], user_trust = groups[5], client_trust = groups[6], machtype = groups[7], location = urllib.unquote(groups[8]), group = groups[9], state = urllib.unquote(groups[10]), state_time = groups[11] or 0, data = urllib.unquote(groups[12]))
self.updateNicklist(user)
user.prnt(self.buffer, weechat.prefix('network'))
def _ns_parse_user_cmd_state(self, arglist) :
user = self._ns_parse_from(arglist[1])
if user.login in self.contacts and user.fd in self.contacts[user.login] :
user = self.contacts[user.login][user.fd]
state = arglist[4].split(':')
user.state = urllib.unquote(state[0])
user.state_time = int(time.time())
self.updateNicklist(user)
chat = self.getChatByRecipient(fd = user.fd)
if chat is not None :
weechat.prnt(chat.buffer, '%s%s%s changed state : %s' % (weechat.prefix('network'), weechat.color('nick_color'), user.login, user.state))
def _ns_parse_user_cmd_login(self, arglist) :
user = self._ns_parse_from(arglist[1])
self._ns_user_cmd_who(':%s' % user.fd)
chat = self.getChatByRecipient(fd = user.fd)
if chat is not None :
weechat.prnt(chat.buffer, '%s%s%s has connected' % (weechat.prefix('join'), weechat.color('nick_color'), user.login))
def _ns_parse_user_cmd_logout(self, arglist) :
user = self._ns_parse_from(arglist[1])
self.updateNicklist(user, remove = True)
chat = self.getChatByRecipient(fd = user.fd)
if chat is not None :
weechat.prnt(chat.buffer, '%s%s%s has disconnected' % (weechat.prefix('quit'), weechat.color('nick_color'), user.login))
########################################
# Weechat callbacks
########################################
def weeNS_buffer_input_cb(data, buffer, input_data) :
global server
if server.isConnected() :
server.getChatByBuffer(buffer).send(input_data)
return weechat.WEECHAT_RC_OK
def weeNS_buffer_close_cb(data, buffer) :
global server
context = server.getChatByBuffer(buffer)
context.buffer = None
context.delete()
return weechat.WEECHAT_RC_OK
def weeNS_server_section_read_cb(data, config_file, section, option_name, value) :
global server
return weechat.config_option_set(server.options[option_name], value, 0)
def weeNS_hook_fd_cb(data, fd) :
global server
server.recv()
return weechat.WEECHAT_RC_OK
def weeNS_script_unload_cb() :
global weeNS_config_file
weechat.config_write(weeNS_config_file)
return weechat.WEECHAT_RC_OK
def weeNS_hook_cmd_ns(data, buffer, args) :
global server
buffer = server.buffer if server.buffer is not None else ''
arglist = args.split(' ')
if arglist[0] == 'connect' and not server.isConnected():
server.connect()
elif arglist[0] == 'disconnect' and server.isConnected() :
server.disconnect()
elif arglist[0] == 'send' and server.isConnected() and len(arglist) > 2 :
match = re.match(re.compile('\A([a-z_]+)|:([0-9]+)\Z'), arglist[1])
if match is not None :
groups = match.groups()
msg = ' '.join(arglist[2:])
server.getChatByRecipient(groups[0], groups[1], create = True).send(msg)
else :
weechat.prnt(buffer, 'Message recipient must be of type login_x[:fd]')
elif arglist[0] == 'who' and server.isConnected() and len(arglist) > 1 :
server._ns_user_cmd_who(arglist[1])
elif arglist[0] == 'state' and server.isConnected() and len(arglist) > 1 :
server._ns_state(arglist[1])
else :
weechat.prnt(buffer, '%sNo such command, wrong argument count, or you need to (dis)connect' % weechat.prefix('error'))
return weechat.WEECHAT_RC_OK
######################################
# Main
######################################
if __name__ == "__main__" :
if weechat.register(SCRIPT_NAME, SCRIPT_AUTHOR, SCRIPT_VERSION, SCRIPT_LICENSE, SCRIPT_DESC, '', 'weeNS_script_unload_cb'):
weechat.hook_command('ns', 'weeNetsoul main command', 'connect | disconnect | send <login> <msg> | state <status> | who <login>',
" connect : Connect\n"
" disconnect : Diconnect\n"
" send : Send <msg> to <login> (any client) or to <:fd> (unique client)\n"
" state : Change status to <status> (en ligne/actif/whatever)\n"
" who : Show infos about <login>\n",
'connect|disconnect|send|state|who', 'weeNS_hook_cmd_ns', '')
weeNS_config_file = weechat.config_new(SCRIPT_NAME, '', '')
weeNS_config_server_section = weechat.config_new_section(weeNS_config_file, 'server', 0, 0, 'weeNS_server_section_read_cb', '', '', '', '', '', '', '', '', '')
server = weeNSServer()
weechat.config_read(weeNS_config_file)
weechat.config_write(weeNS_config_file)
Back to scripts |
Download