Code: Alles auswählen
$ cat /etc/hosts
> 127.0.0.1 localhost
> 127.0.1.1 industrial
>
> # The following lines are desirable for IPv6 capable hosts
> ::1 ip6-localhost ip6-loopback
> fe00::0 ip6-localnet
> ff00::0 ip6-mcastprefix
> ff02::1 ip6-allnodes
> ff02::2 ip6-allrouters
> ff02::3 ip6-allhosts
Mir ist auch rätselhaft weswegen da 127.0.1.1 drin steht. Ich hab nicht dran rumgefummelt, das scheint in Ubuntu 7.04 standardmäßig so zu laufen. Ich hab gerade auf dem anderen Rechner (deskpro, 192.168.2.17) nachgeschaut, dort ist der Name auch auf 127.0.1.1 gemapped.
Habe jetzt auch mit PHP und C mal Versuche gemacht, selbes Resultat.
Wie dem auch sei, mit dem 127.0.1.1 verstehe ich warum unter root der Port 86 in obigem Beispiel nicht nach außen hin geöffnet wurde.
Der Client-Rechner den ich verwende ist bestimmt richtig konfiguriert. Jeder andere Dienst funktioniert ja auch (/home via NFS mounten, Benutzerauthentifizierung via LDAP, HTTP, FTP, BattleNet-Gaming-Server).
Wenn ich's nicht als root ausführe werden die Ports 8117 bis 8122 gebunden, wie zuvor ist allerdings keiner sichtbar für die Außenwelt.
Die Ausgabe von netstat sagt was anderes. Hast du deinen "Server" mal gescannt? Mindestens 192.168.2.23:8117 muss öffentlich verfügbar sein.
Diese Ausgabe habe ich aufgerufen als das Script als root lief. Als normaler User sieht's aber genauso aus, nur dass eben 81 bis 86 nicht auftauchen.
192.168.2.23:8117 ist definitiv nicht öffentlich verfügbar, ich prüfe das auch mit 'nem Portscan (daher weiß ich auch dass 82 bis 85 sichtbar waren, der Rest eben nicht).
Ich bin mit meinem latein total am Ende.
Das hier ist übrigens das Server-Script welches ich geschrieben habe:
Code: Alles auswählen
from threading import *
from SimpleXMLRPCServer import SimpleXMLRPCServer
import hashlib
import random
import xmlrpclib
import sys
import time
import socket
from Queue import *
# Helping classes
class Config:
def __init__(self, **dict):
for i in dict:
self.__dict__[i] = dict[i]
users = {"warhog": "qwe123", "martin": "asd456"}
cfg = Config(port=8117, host="0.0.0.0")
sessions = {}
class Session:
def __init__(self, server):
self.id = hashlib.md5(str(random.randint(0, 16777216))).hexdigest()
self.server = server
sessions[self.id] = self
self.auth = False
self.update()
def check(self):
if self.time + 300 > time.time():
self.update()
return True
else:
self.delete()
return False
def update(self):
self.time = time.time()
def delete(self):
del sessions[self.id]
def authed(self):
return self.auth
def auth_ok(self, ok):
self.auth = not not ok
tickets = {}
class Ticket:
def __init__(self, sender):
self.id = hashlib.md5(str(random.randint(0, 16777216))).hexdigest()
self.sender = sender
tickets[self.id] = self
def punch(self):
del tickets[self.id]
# These are RPC-functions
def request(sessionID, action, argument):
if (ok(sessionID)):
ticket = Ticket(sessionID)
q.put((ticket.id, action, argument))
return ticket.id
else:
return False
def hai(server, port=8119):
session = Session((server, port))
return session.id
def bye(sessionID):
"logout"
if ok(sessionID):
sessions[sessionID].delete()
return True
else:
return False
def auth(sessionID, user, password=""):
"authentication of a user"
if sessionID not in sessions:
return False
if user in users:
if users[user] == password:
sessions[sessionID].auth_ok(True)
return True
return False
def login(user, password=None, server="localhost", port=8119):
"does 'hai' and 'auth' at once"
sid = hai(server, port)
if auth(sid, user, password):
return sid
else:
return False
def status(sessionID):
return {"sessions": sessions, "tickets": tickets}
# These are helping functions
def ok(sessionID):
if sessionID in sessions:
if sessions[sessionID].check():
return sessions[sessionID].authed()
else:
return False
else:
return False
# The thing to do
q = Queue()
l1 = Lock() # output lock
l2 = Lock() # access to sessions/tickets lock
def log(message):
print message
def zensor():
w = q.get()
l1.acquire()
log("S "+w[0]+"("+w[1]+", "+w[2]+")")
l1.release()
time.sleep(20)
l1.acquire()
log("F "+w[0])
l1.release()
q.task_done()
for i in range(5):
t = Thread(target=zensor)
t.setDaemon(True)
t.start()
server = SimpleXMLRPCServer((cfg.host, cfg.port))
server.register_introspection_functions()
server.register_function(hai)
server.register_function(auth)
server.register_function(request)
server.register_function(bye)
server.register_function(status)
server.register_function(login)
server.serve_forever()
'nen Client-Script gibt's noch nicht, ich teste immer alles in der interaktiven Shell, ungefähr so
Code: Alles auswählen
import xmlrpclib
s = xmlrpclib.Server("http://localhost:8117");
sid = s.hai("localhost");
s.auth(sid, "warhog", "qwe123");
s.status(sid);
lokal funktioniert das, von nem anderen rechner aus nicht. Ich hab das mittlerweile auch schon in nem interaktiven Python-Shell auf nem Windows-XP versucht. Der Port ist eben definitv nur lokal sichtbar!
gruß, Warhog
