IRC gateway: Difference between revisions
m
→{{header|Wren}}: Minor tidy
m (→{{header|Wren}}: Minor tidy) |
|||
| (3 intermediate revisions by 3 users not shown) | |||
Line 5:
<br>
Just a bare-bones gateway.
<
import (
Line 78:
go irc2.Loop()
irc1.Loop()
}</
=={{header|Phix}}==
<!--<
For use with [[Chat_server#Phix]]
<span style="color: #000080;font-style:italic;">--
Line 242:
<span style="color: #000080;font-style:italic;">--?"done"
--{} = wait_key()</span>
<!--</
=={{header|Tcl}}==
This code is called as a complete script, perhaps like this:
<
{{tcllib|picoirc}}
<
package require picoirc
Line 290:
set conn(1) [picoirc::connect handle1to2 $nick1 $url1]
set conn(2) [picoirc::connect handle2to1 $nick2 $url2]
vwait forever</
=={{header|Wren}}==
{{trans|Go}}
{{libheader|WrenGo}}
{{libheader|go-ircevent}}
{{libheader|Wren-dynamic}}
An embedded application with a Go host so we can use the 'go-ircevent' library.
As it's not possible to access command line arguments directly from Wren when it is being embedded, we instead ask the gateway user to input details of the connections needed.
<syntaxhighlight lang="wren">/* IRC_gateway.wren */
import "./dynamic" for Tuple
var Connection = Tuple.create("Connection", ["server", "channel", "nick", "user"])
foreign class IRC {
construct new(number, nick, user) {}
foreign connect(server)
foreign verboseCallbackHandler=(arg)
foreign debug=(arg)
foreign useTLS=(arg)
foreign configTLS=(arg)
foreign addCallback(number, code, msg, channel, nick, otherNick)
}
foreign class Reader {
construct new() {}
foreign readLine()
}
var reader = Reader.new()
var Connections = List.filled(2, null)
System.print("To use this gateway, please enter the following:\n")
for (i in 0..1) {
System.print("Details for connection %(i+1):")
System.write(" Server : ")
var server = reader.readLine()
System.write(" Channel : ")
var channel = reader.readLine()
System.write(" Nickname : ")
var nick = reader.readLine()
System.write(" User : ")
var user = reader.readLine()
Connections[i] = Connection.new(server, channel, nick, user)
System.print()
}
for (i in 0..1) {
var c = Connections[i]
var irc = IRC.new(i, c.nick, c.user)
irc.verboseCallbackHandler = true
irc.debug = false
irc.useTLS = true
irc.configTLS = true
var otherNick = (i == 0) ? Connections[1].nick : Connections[0].nick
var msg
if (i == 0) {
msg = "<gateway> Hello %(c.nick). Please send your first message to %(otherNick)."
} else {
msg = "<gateway> Hello %(c.nick). Please wait for your first message from %(otherNick)."
}
irc.addCallback(i, "001", msg, c.channel, c.nick, otherNick)
irc.addCallback(i, "366", "" , c.channel, c.nick, otherNick)
irc.addCallback(i, "PRIVMSG", "" , c.channel, c.nick, otherNick)
irc.connect(c.server)
}</syntaxhighlight>
We now embed this script in the following Go program and run it from a terminal. To close the gateway just press Ctrl-C.
<syntaxhighlight lang="go">/* go run IRC_gateway.go */
package main
import (
"bufio"
"crypto/tls"
"fmt"
wren "github.com/crazyinfin8/WrenGo"
"github.com/thoj/go-ircevent"
"log"
"os"
"strings"
)
type any = interface{} // not needed if using Go v1.18 or later
var ircObjs [2]*irc.Connection
func newIRC(vm *wren.VM, parameters []any) (any, error) {
number := int(parameters[1].(float64))
nick := parameters[2].(string)
user := parameters[3].(string)
ircObjs[number] = irc.IRC(nick, user)
return &ircObjs[number], nil
}
func connect(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
server := parameters[1].(string)
err := ircObj.Connect(server)
if err != nil {
log.Fatal(err)
}
return nil, nil
}
func setVerboseCallbackHandler(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
value := parameters[1].(bool)
ircObj.VerboseCallbackHandler = value
return nil, nil
}
func setDebug(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
value := parameters[1].(bool)
ircObj.Debug = value
return nil, nil
}
func setUseTLS(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
value := parameters[1].(bool)
ircObj.UseTLS = value
return nil, nil
}
func setConfigTLS(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
value := parameters[1].(bool)
ircObj.TLSConfig = &tls.Config{InsecureSkipVerify: value}
return nil, nil
}
func addCallback(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
ircObj := *(ifc.(**irc.Connection))
number := int(parameters[1].(float64))
code := parameters[2].(string)
msg := parameters[3].(string)
channel := parameters[4].(string)
nick := parameters[5].(string)
otherNick := parameters[6].(string)
if code == "001" {
ircObj.AddCallback("001", func(e *irc.Event) {
ircObj.Join(channel)
ircObj.Privmsg(nick, msg)
log.Println(msg)
})
} else if code == "366" {
ircObj.AddCallback("366", func(e *irc.Event) {})
} else if code == "PRIVMSG" {
ircObj.AddCallback("PRIVMSG", func(e *irc.Event) {
msg := fmt.Sprintf("<%s> %s", nick, e.Message)
if number == 0 {
ircObjs[1].Privmsg(otherNick, msg)
} else {
ircObjs[0].Privmsg(otherNick, msg)
}
log.Println(msg)
})
}
return nil, nil
}
func newReader(vm *wren.VM, parameters []any) (any, error) {
reader := bufio.NewReader(os.Stdin)
return &reader, nil
}
func readLine(vm *wren.VM, parameters []any) (any, error) {
handle := parameters[0].(*wren.ForeignHandle)
ifc, _ := handle.Get()
bufin := *(ifc.(**bufio.Reader))
s, _ := bufin.ReadString('\n') // includes the delimiter
return s[:len(s)-1], nil
}
func moduleFn(vm *wren.VM, name string) (string, bool) {
if name != "meta" && name != "random" && !strings.HasSuffix(name, ".wren") {
name += ".wren"
}
return wren.DefaultModuleLoader(vm, name)
}
func main() {
cfg := wren.NewConfig()
cfg.LoadModuleFn = moduleFn
vm := cfg.NewVM()
var fileName = "IRC_gateway.wren"
IRCMethodMap := wren.MethodMap{
"connect(_)": connect,
"verboseCallbackHandler=(_)": setVerboseCallbackHandler,
"debug=(_)": setDebug,
"useTLS=(_)": setUseTLS,
"configTLS=(_)": setConfigTLS,
"addCallback(_,_,_,_,_,_)": addCallback,
}
readerMethodMap := wren.MethodMap{"readLine()": readLine}
classMap := wren.ClassMap{
"IRC": wren.NewClass(newIRC, nil, IRCMethodMap),
"Reader": wren.NewClass(newReader, nil, readerMethodMap),
}
module := wren.NewModule(classMap)
vm.SetModule(fileName, module)
vm.InterpretFile(fileName)
go ircObjs[1].Loop()
ircObjs[0].Loop()
vm.Free()
}</syntaxhighlight>
{{omit from|AWK}}
| |||