Connection refused.again

aris · August 17, 2012, 4:22pm

Hello,

i have a very stubborn error coming up every time: Connection refused.
I read in the topics here, that it might be because the firewall blocks
the signal. So i opened the port 7654 on the router (a “fritz box”),
which solved the problem, but the next day I got that error again. I
tried to run the programm on Windows 7 and Ubuntu 11.10 after opening
the port (with firestarter in Ubuntu) in both systems, but the error
continues to show up.

Can you please help me?

krepusko · August 17, 2012, 4:41pm

On Fri, Aug 17, 2012 at 4:23 PM, Waldemar R. [email protected]
wrote:

Can you please help me?

Unlikely as long as you do not disclose any details about what you are
trying to do and what program you are using.

Cheers

robert

krepusko · August 17, 2012, 5:44pm

Robert K. wrote in post #1072672:

On Fri, Aug 17, 2012 at 4:23 PM, Waldemar R. [email protected]
wrote:

Can you please help me?

Unlikely as long as you do not disclose any details about what you are
trying to do and what program you are using.

Cheers

robert

I am very sorry, i totally forgot it.
I am using RGSS with the library of Ruby 1.8.1 to get a modified version
of the Server/Client example from www.ruby-doc.org to run.

Server:
$s = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM,
Socket::IPPROTO_TCP)
$ais = Socket.sockaddr_in(7654, nil)
$s.bind($ais)
Kernel.pbMessage(_INTL(“Waiting for Player.”))
$s.listen(2)
client=$s.accept
client.puts “Hello!”
Kernel.pbMessage(_INTL(“Server initialisiert”))

Client:
$c = Socket.new(Socket::AF_UNSPEC, Socket::SOCK_STREAM,
Socket::IPPROTO_TCP)
$aic = Socket.sockaddr_in(7654, ‘127.0.0.1’)
$c.connect($aic)
print(“Client initialised.”)

And the error message points to following line, marked between (*)

class SocketError < StandardError
ENOASSOCHOST = “getaddrinfo: no address associated with hostname.”

def self.check
errno = Winsock.WSAGetLastError
#if not Network.testing? == 1
() raise Errno.const_get(Errno.constants.detect { |c|
Errno.const_get(c).new.errno == errno }) ()
#else
# errno != 0 ? (Network.testresult(true)) :
(Network.testresult(false))
#end
end
end

krepusko · August 17, 2012, 6:06pm

On Fri, Aug 17, 2012 at 5:44 PM, Waldemar R. [email protected]
wrote:

I am very sorry, i totally forgot it.

client=$s.accept
#else
#  errno != 0 ? (Network.testresult(true)) :
(Network.testresult(false))
#end
end
end

Well, if you comment the condition around the raise then of course
every call to #check will trigger the exception. Is that your
problem?

Kind regards

robert

krepusko · August 17, 2012, 11:34pm

Robert K. wrote in post #1072689:

On Fri, Aug 17, 2012 at 5:44 PM, Waldemar R. [email protected]
wrote:
#else
#  errno != 0 ? (Network.testresult(true)) :
(Network.testresult(false))
#end
end
end
Well, if you comment the condition around the raise then of course
every call to #check will trigger the exception. Is that your
problem?

Unfortunately not. If it would work by removing the comments, or by
making the entire condition a comment, there should appear an error
regarding the line “$c.connect($aic)”, because yesterday i got this far
and someone else got the same problem with last line, but not the one
troubling me at the moment. Instead I get the following answers:
First by making the problem to a comment, the program just hangs up.
Second by removing everything commented in SocketError I get the message
“Script ‘Sockets’ line 526:NameError occurred. uninitialized constant
SocketError::Network”.
This seems to me, that I need to make Network an object from a class I
don’t know and to make a method called testing. What should testing do?
As far I understand this method should work like a ping and by
successful pinging return the value 1 else 0, shouldn’t it? For the case
this is not right, I paste here the script of the original author:
module Win32
def copymem(len)
buf = “\0” * len
Win32API.new(“kernel32”, “RtlMoveMemory”, “ppl”, “”).call(buf, self,
len)
buf
end
end

Extends the numeric class.

class Numeric
include Win32
end

Extends the string class.

class String
include Win32
end

module Winsock
DLL = “ws2_32”
#-----------------------------------------------------------------------------

* Accept Connection

#-----------------------------------------------------------------------------
def self.accept(*args)
Win32API.new(DLL, “accept”, “ppl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Bind

#-----------------------------------------------------------------------------
def self.bind(*args)
Win32API.new(DLL, “bind”, “ppl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Close Socket

#-----------------------------------------------------------------------------
def self.closesocket(*args)
Win32API.new(DLL, “closesocket”, “p”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Connect

#-----------------------------------------------------------------------------
def self.connect(*args)
Win32API.new(DLL, “connect”, “ppl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Get host (Using Adress)

#-----------------------------------------------------------------------------
def self.gethostbyaddr(*args)
Win32API.new(DLL, “gethostbyaddr”, “pll”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Get host (Using Name)

#-----------------------------------------------------------------------------
def self.gethostbyname(*args)
Win32API.new(DLL, “gethostbyname”, “p”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Get host’s Name

#-----------------------------------------------------------------------------
def self.gethostname(*args)
Win32API.new(DLL, “gethostname”, “pl”, “”).call(*args)
end
#-----------------------------------------------------------------------------

* Get Server (Using Name)

#-----------------------------------------------------------------------------
def self.getservbyname(*args)
Win32API.new(DLL, “getservbyname”, “pp”, “p”).call(*args)
end
#-----------------------------------------------------------------------------

* Convert Host Long To Network Long

#-----------------------------------------------------------------------------
def self.htonl(*args)
Win32API.new(DLL, “htonl”, “l”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Convert Host Short To Network Short

#-----------------------------------------------------------------------------
def self.htons(*args)
Win32API.new(DLL, “htons”, “l”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Inet Adress

#-----------------------------------------------------------------------------
def self.inet_addr(*args)
Win32API.new(DLL, “inet_addr”, “p”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Inet N To A

#-----------------------------------------------------------------------------
def self.inet_ntoa(*args)
Win32API.new(DLL, “inet_ntoa”, “l”, “p”).call(*args)
end
#-----------------------------------------------------------------------------

* Listen

#-----------------------------------------------------------------------------
def self.listen(*args)
Win32API.new(DLL, “listen”, “pl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Recieve

#-----------------------------------------------------------------------------
def self.recv(*args)
Win32API.new(DLL, “recv”, “ppll”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Select

#-----------------------------------------------------------------------------
def self.select(*args)
Win32API.new(DLL, “select”, “lpppp”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Send

#-----------------------------------------------------------------------------
def self.send(*args)
Win32API.new(DLL, “send”, “ppll”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Set Socket Options

#-----------------------------------------------------------------------------
def self.setsockopt(*args)
Win32API.new(DLL, “setsockopt”, “pllpl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Shutdown

#-----------------------------------------------------------------------------
def self.shutdown(*args)
Win32API.new(DLL, “shutdown”, “pl”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Socket

#-----------------------------------------------------------------------------
def self.socket(*args)
Win32API.new(DLL, “socket”, “lll”, “l”).call(*args)
end
#-----------------------------------------------------------------------------

* Get Last Error

#-----------------------------------------------------------------------------
def self.WSAGetLastError(*args)
Win32API.new(DLL, “WSAGetLastError”, “”, “l”).call(*args)
end
end

if !Object.const_defined?(:Socket) # for compatibility

#===============================================================================

** Socket - Creates and manages sockets.

#-------------------------------------------------------------------------------

Author Ruby

Version 1.8.1

#===============================================================================
class Socket
#-----------------------------------------------------------------------------

* Constants

#-----------------------------------------------------------------------------
AF_UNSPEC = 0
AF_UNIX = 1
AF_INET = 2
AF_IPX = 6
AF_APPLETALK = 16
PF_UNSPEC = 0
PF_UNIX = 1
PF_INET = 2
PF_IPX = 6
PF_APPLETALK = 16
SOCK_STREAM = 1
SOCK_DGRAM = 2
SOCK_RAW = 3
SOCK_RDM = 4
SOCK_SEQPACKET = 5
IPPROTO_IP = 0
IPPROTO_ICMP = 1
IPPROTO_IGMP = 2
IPPROTO_GGP = 3
IPPROTO_TCP = 6
IPPROTO_PUP = 12
IPPROTO_UDP = 17
IPPROTO_IDP = 22
IPPROTO_ND = 77
IPPROTO_RAW = 255
IPPROTO_MAX = 256
SOL_SOCKET = 65535
SO_DEBUG = 1
SO_REUSEADDR = 4
SO_KEEPALIVE = 8
SO_DONTROUTE = 16
SO_BROADCAST = 32
SO_LINGER = 128
SO_OOBINLINE = 256
SO_RCVLOWAT = 4100
SO_SNDTIMEO = 4101
SO_RCVTIMEO = 4102
SO_ERROR = 4103
SO_TYPE = 4104
SO_SNDBUF = 4097
SO_RCVBUF = 4098
SO_SNDLOWAT = 4099
TCP_NODELAY = 1
MSG_OOB = 1
MSG_PEEK = 2
MSG_DONTROUTE = 4
IP_OPTIONS = 1
IP_DEFAULT_MULTICAST_LOOP = 1
IP_DEFAULT_MULTICAST_TTL = 1
IP_MULTICAST_IF = 2
IP_MULTICAST_TTL = 3
IP_MULTICAST_LOOP = 4
IP_ADD_MEMBERSHIP = 5
IP_DROP_MEMBERSHIP = 6
IP_TTL = 7
IP_TOS = 8
IP_MAX_MEMBERSHIPS = 20
EAI_ADDRFAMILY = 1
EAI_AGAIN = 2
EAI_BADFLAGS = 3
EAI_FAIL = 4
EAI_FAMILY = 5
EAI_MEMORY = 6
EAI_NODATA = 7
EAI_NONAME = 8
EAI_SERVICE = 9
EAI_SOCKTYPE = 10
EAI_SYSTEM = 11
EAI_BADHINTS = 12
EAI_PROTOCOL = 13
EAI_MAX = 14
AI_PASSIVE = 1
AI_CANONNAME = 2
AI_NUMERICHOST = 4
AI_MASK = 7
AI_ALL = 256
AI_V4MAPPED_CFG = 512
AI_ADDRCONFIG = 1024
AI_DEFAULT = 1536
AI_V4MAPPED = 2048
#--------------------------------------------------------------------------

* Returns the associated IP address for the given hostname.

#--------------------------------------------------------------------------
def self.getaddress(host)
gethostbyname(host)[3].unpack(“C4”).join(“.”)
end
#--------------------------------------------------------------------------

* Returns the associated IP address for the given hostname.

#--------------------------------------------------------------------------
def self.getservice(serv)
case serv
when Numeric
return serv
when String
return getservbyname(serv)
else
raise “Please use an integer or string for services.”
end
end
#--------------------------------------------------------------------------

* Returns information about the given hostname.

#--------------------------------------------------------------------------
def self.gethostbyname(name)
raise SocketError::ENOASSOCHOST if (ptr =
Winsock.gethostbyname(name)) == 0
host = ptr.copymem(16).unpack(“iissi”)
[host[0].copymem(64).split(“\0”)[0], [], host[2],
host[4].copymem(4).unpack(“l”)[0].copymem(4)]
end
#--------------------------------------------------------------------------

* Returns the user’s hostname.

#--------------------------------------------------------------------------
def self.gethostname
buf = “\0” * 256
Winsock.gethostname(buf, 256)
buf.strip
end
#--------------------------------------------------------------------------

* Returns information about the given service.

#--------------------------------------------------------------------------
def self.getservbyname(name)
case name
when /echo/i
return 7
when /daytime/i
return 13
when /ftp/i
return 21
when /telnet/i
return 23
when /smtp/i
return 25
when /time/i
return 37
when /http/i
return 80
when /pop/i
return 110
else
#Network.testing? != 0 ? (Network.testresult(true)) : (raise
“Service not recognized.”)
#return if Network.testing? == 2
end
end
#--------------------------------------------------------------------------

* Creates an INET-sockaddr struct.

#--------------------------------------------------------------------------
def self.sockaddr_in(port, host)
begin
[AF_INET, getservice(port)].pack(“sn”) + gethostbyname(host)[3] +
[].pack(“x8”)
rescue
#Network.testing? != 0 ? (Network.testresult(true)): (nil)
#return if Network.testing? == 2
rescue Hangup
#Network.testing? != 0 ? (Network.testresult(true)): (nil)
#return if Network.testing? == 2
end
end
#--------------------------------------------------------------------------

* Creates a new socket and connects it to the given host and port.

#--------------------------------------------------------------------------
def self.open(*args)
socket = new(*args)
if block_given?
begin
yield socket
ensure
socket.close
end
end
nil
end
#--------------------------------------------------------------------------

* Creates a new socket.

#--------------------------------------------------------------------------
def initialize(domain, type, protocol)
SocketError.check if (@fd = Winsock.socket(domain, type, protocol))
== -1
@fd
end
#--------------------------------------------------------------------------

* Accepts incoming connections.

#--------------------------------------------------------------------------
def accept(flags = 0)
buf = “\0” * 16
SocketError.check if Winsock.accept(@fd, buf, flags) == -1
buf
end
#--------------------------------------------------------------------------

* Binds a socket to the given sockaddr.

#--------------------------------------------------------------------------
def bind(sockaddr)
SocketError.check if (ret = Winsock.bind(@fd, sockaddr,
sockaddr.size)) == -1
ret
end
#--------------------------------------------------------------------------

* Closes a socket.

#--------------------------------------------------------------------------
def close
SocketError.check if (ret = Winsock.closesocket(@fd)) == -1
ret
end
#--------------------------------------------------------------------------

* Connects a socket to the given sockaddr.

#--------------------------------------------------------------------------
def connect(sockaddr)
#return if Network.testing? == 2
SocketError.check if (ret = Winsock.connect(@fd, sockaddr,
sockaddr.size)) == -1
ret
end
#--------------------------------------------------------------------------

* Listens for incoming connections.

#--------------------------------------------------------------------------
def listen(backlog)
SocketError.check if (ret = Winsock.listen(@fd, backlog)) == -1
ret
end
#--------------------------------------------------------------------------

* Checks waiting data’s status.

#--------------------------------------------------------------------------
def select(timeout) # timeout in seconds
SocketError.check if (ret = Winsock.select(1, [1, @fd].pack(“ll”),
0, 0, [timeout.to_i,
(timeout * 1000000).to_i].pack(“ll”))) == -1
ret
end
#--------------------------------------------------------------------------

* Checks if data is waiting.

#--------------------------------------------------------------------------
def ready?
not select(0) == 0
end
#--------------------------------------------------------------------------

* Reads data from socket.

#--------------------------------------------------------------------------
def read(len)
buf = “\0” * len
Win32API.new(“msvcrt”, “_read”, “lpl”, “l”).call(@fd, buf, len)
buf
end
#--------------------------------------------------------------------------

* Returns received data.

#--------------------------------------------------------------------------
def recv(len, flags = 0)
retString=“”
remainLen=len
while remainLen > 0
buf = “\0” * remainLen
retval=Winsock.recv(@fd, buf, buf.size, flags)
SocketError.check if retval == -1
# Note: Return value may not equal requested length
remainLen-=retval
retString+=buf[0,retval]
end
return retString
end
#--------------------------------------------------------------------------

* Sends data to a host.

#--------------------------------------------------------------------------
def send(data, flags = 0)
SocketError.check if (ret = Winsock.send(@fd, data, data.size,
flags)) == -1
ret
end
#--------------------------------------------------------------------------

* Recieves file from a socket

size : file size

scene : update scene boolean

#--------------------------------------------------------------------------
def recv_file(size,scene=false,file=“”)
data = []
size.times do |i|
if scene == true
$scene.recv_update(size,i,file) if i%((size/1000)+1)== 0
else
Graphics.update if i%1024 == 0
end
data << recv(1)
end
return data
end

def recvTimeout
if select(10)==0
raise Hangup.new(“Timeout”)
end
return recv(1)
end
#--------------------------------------------------------------------------

* Gets

#--------------------------------------------------------------------------
def gets
# Create buffer
message = “”
# Loop Until “end of line”
count=0
while true
x=select(0.05)
if x==0
count+=1
Graphics.update if count%10==0
raise Errno::ETIMEOUT if count>200
next
end
ch = recv(1)
break if ch == “\n”
message += ch
end
# Return recieved data
return message
end
#--------------------------------------------------------------------------

* Writes data to socket.

#--------------------------------------------------------------------------
def write(data)
Win32API.new(“msvcrt”, “_write”, “lpl”, “l”).call(@fd, data, 1)
end
end

#===============================================================================

** TCPSocket - Creates and manages TCP sockets.

#-------------------------------------------------------------------------------

Author Ruby

Version 1.8.1

#===============================================================================

#-------------------------------------------------------------------------------

Begin SDK Enabled Check

#-------------------------------------------------------------------------------
class TCPSocket < Socket
#--------------------------------------------------------------------------

* Creates a new socket and connects it to the given host and port.

#--------------------------------------------------------------------------
def self.open(*args)
socket = new(*args)
if block_given?
begin
yield socket
ensure
socket.close
end
end
nil
end
#--------------------------------------------------------------------------

* Creates a new socket and connects it to the given host and port.

#--------------------------------------------------------------------------
def initialize(host, port)
super(AF_INET, SOCK_STREAM, IPPROTO_TCP)
connect(Socket.sockaddr_in(port, host))
end
end

#==============================================================================

** SocketError

#------------------------------------------------------------------------------

Default exception class for sockets.

#==============================================================================
class SocketError < StandardError
ENOASSOCHOST = “getaddrinfo: no address associated with hostname.”

def self.check
errno = Winsock.WSAGetLastError
#if not Network.testing? == 1
raise Errno.const_get(Errno.constants.detect { |c|
Errno.const_get(c).new.errno == errno })
#else
# errno != 0 ? (Network.testresult(true)) :
(Network.testresult(false))
#end
end
end

end # !Object.const_defined?(:Socket)

#############################

HTTP utility functions

#############################
def pbPostData(url, postdata, filename=nil, depth=0)
userAgent=“Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US;
rv:1.9.0.14) Gecko/2009082707 Firefox/3.0.14”
if url[/^http://([^/]+)(.*)$/]
host=$1
path=$2
path=“/” if path.length==0
body = postdata.map {|key, value|
keyString=key.to_s
valueString=value.to_s
keyString.gsub!(/[^a-zA-Z0-9_.-]/n) {|s| sprintf(‘%%%02x’,
s[0]) }
valueString.gsub!(/[^a-zA-Z0-9_.-]/n) {|s| sprintf(‘%%%02x’,
s[0]) }
next “#{keyString}=#{valueString}”
}.join(‘&’)
request=“POST #{path} HTTP/1.1\nUser-Agent: #{userAgent}\nPragma:
no-cache\nHost: #{host}\nProxy-Connection: Close\n”
request+=“Content-Type: application/x-www-form-urlencoded\n”
request+=“Content-Length: #{body.length}\n”
request+=“\n”
request+=body
return pbHttpRequest(host, request, filename, depth)
end
return “”
end

def pbDownloadData(url, filename=nil, depth=0)
userAgent=“Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US;
rv:1.9.0.14) Gecko/2009082707 Firefox/3.0.14”
if depth>10
raise “Redirection level too deep”
end
if url[/^http://([^/]+)(.*)$/]
host=$1
path=$2
path=“/” if path.length==0
request=“GET #{path} HTTP/1.1\nUser-Agent: #{userAgent}\nPragma:
no-cache\nHost: #{host}\nProxy-Connection: Close\n\n”
return pbHttpRequest(host, request, filename, depth)
end
return “”
end

def pbHttpRequest(host, request, filename=nil, depth=0)
if depth>10
raise “Redirection level too deep”
end
socket=::TCPSocket.new(host, 80)
time=Time.now.to_i
begin
socket.send(request)
result=socket.gets
data=“”
# Get the HTTP result
if result[/^HTTP/1.[01] (\d+)./]
errorcode=$1.to_i
if errorcode>=400 && errorcode<500
raise “HTTP Error #{errorcode}”
end
headers={}
# Get the response headers
while true
result=socket.gets.sub(/\r$/,“”)
break if result==“”
if result[/^([^:]+):\s(.*)/]
headers[$1]=$2
end
end
length=-1
chunked=false
if headers[“Content-Length”]
length=headers[“Content-Length”].to_i
end
if headers[“Transfer-Encoding”]==“chunked”
chunked=true
end
if headers[“Location”] && errorcode >= 300 && errorcode < 400
socket.close rescue socket=nil
return pbDownloadData(headers[“Location”],filename,depth+1)
end
if chunked==true
# Chunked content
while true
lengthline=socket.gets.sub(/\r$/,“”)
length=lengthline.to_i(16)
break if length==0
while Time.now.to_i-time>=5 || socket.select(10)==0
time=Time.now.to_i
Graphics.update
end
data+=socket.recv(length)
socket.gets
end
elsif length==-1
# No content length specified
while true
if socket.select(500)==0
break
else
while Time.now.to_i-time>=5 || socket.select(10)==0
time=Time.now.to_i
Graphics.update
end
data+=socket.recv(1)
end
end
else
# Content length specified
while length>0
chunk=[length,4096].min
while Time.now.to_i-time>=5 || socket.select(10)==0
time=Time.now.to_i
Graphics.update
end
data+=socket.recv(chunk)
length-=chunk
end
end
end
if filename
File.open(filename,“wb”){|f|
f.write(data)
}
else
return data
end
ensure
socket.close rescue socket=nil
end
return “”
end

def pbDownloadToString(url)
begin
data=pbDownloadData(url)
return data
rescue
return “”
end
end

def pbDownloadToFile(url, file)
begin
pbDownloadData(url,file)
rescue
end
end

def pbPostToString(url, postdata)
begin
data=pbPostData(url, postdata)
return data
rescue
return “”
end
end

def pbPostToFile(url, postdata, file)
begin
pbPostData(url, postdata,file)
rescue
end
end

If I am wrong, the author uses something like the WinAPI integrated in
the RPG Maker or Windows, doesn’t he?
Could it be, that i need to replace the code from Ruby 1.8.1 with the
one from 1.9.3?