get_adress geht nicht richtig!

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Gast

get_adress geht nicht richtig!

Beitragvon Gast » Montag 17. Oktober 2005, 17:16

hi

ich habe probleme mit get_adress !
mei Samserver hat kein get_adress habe schon es einmal intregriert aber es tauchen trotzdem fehler auf!
der orginal rufus client hat die function get_adress im rawserver!

also weis nciht wie ich get_adress richtig zum laufen bringen kann!

ich ein Bittorrent client umgeportet auf I2P netz!
es geht nur ein download der rest nicht!
also 2 oder mehr geht nicht!

und durch get_adress bricht oft oder immer die verbindung ab!
wenn ich z.b. downloade gerade! und klicke drauf auf erste downlaod sofort wirds abgebrochen die verbindung!

hier mein Samserver.py:

!

Code: Alles auswählen

"""
SAM based RawServer replacement

Written by duck in 2004 and released into the public domain.
"""

from bisect import insort
import select, socket
import string
from cStringIO import StringIO
from traceback import print_exc, print_stack
from errno import EINTR, EWOULDBLOCK
from time import time, sleep
from random import randrange

import Logger
import SamBuffer

class SingleSocket:
    def __init__(self, raw_server, sock, handler, logger):
        self.raw_server = raw_server
        # sock is (id, dest)
        self.id = sock[0]
        self.dest = sock[1]
        self.handler = handler
        self.logger = logger
        self.buffer = StringIO()
        self.last_hit = time()
        self.connected = False

    def connect(self):
        self.connected = True

    def close(self):
        """Initiate socket closing."""
        self.raw_server.logger.debug("Sending close to %d", self.id)

        # uncomment to dump the stack to the logs
        #data = StringIO()
        #print_stack(file = data)
        #self.raw_server.logger.debug(data.getvalue())

        self.raw_server._sendClose(self.id)

    ##def get_address(self):
    ##   
    ##   return self.dest
       

    def get_ip(self):
        return self.dest

    def shutdown(self, val):
        self.raw_server.logger.debug("Sending shutdown to %d, level %d", self.id, val)
        self.raw_server._sendClose(self.id)

    def is_flushed(self):
        return self.buffer.tell() == 0

    def write(self, s):
        self.raw_server.logger.debug("Writing to buffer of %d, length %d", self.id, len(s))
        self.buffer.write(s)

    def try_write(self):
        if self.connected:
            self.buffer.seek(0)
            while True:
                nmax = 32768
                block = self.buffer.read(nmax)
                if len(block)>0:
                    self.raw_server.logger.debug("Sending data to %d, length %d", self.id, len(block))
                    self.raw_server._sendData(self.id, block)
                else:
                    self.buffer.reset()
                    self.buffer.truncate()
                    return

def default_error_handler(x):
    print x

class SamServer:
    def __init__(self, doneflag, bind, timeout_check_interval, timeout,
                 sam_bridge, tunnel_depth, tunnel_number, length_variance,
                 noisy = True, errorfunc = default_error_handler,
                 maxconnects = 55):
        # default sam config
        self.samhost = sam_bridge.split(':')[0]
        self.samport = int(sam_bridge.split(':')[1])
        self.version = '1.0'
        self.tunnel_depth = tunnel_depth
        self.tunnel_number = tunnel_number
        self.length_variance = length_variance

        self.connected = False
        self.handshaked = False
        self.bound = False

        if not bind:
            self.sessionname = 'I2P-BT-%d' % randrange(2 ** 30)
        else:
            self.sessionname = bind
        self.mydest = None

        self.samBuffer = SamBuffer.SamBuffer()
        self.outBuffer = []

        self.timeout_check_interval = timeout_check_interval
        self.timeout = timeout
        self.single_sockets = {}
        self.dead_from_write = []
        self.doneflag = doneflag
        self.noisy = noisy
        self.errorfunc = errorfunc
        self.maxconnects = maxconnects
        self.funcs = []
        self.unscheduled_tasks = []

        self.maxId = 0
        self._connect()
        self.add_task(self.scan_for_timeouts, timeout_check_interval)

    def _connect(self):
        """Connect to SAM."""
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.setblocking(0)
        try:
            self.sock.connect_ex((self.samhost, self.samport))
        except socket.error:
            raise
        except Exception, e:
            raise socket.error(str(e))
        self.handshaked = False

    def _disconnect(self):
        """Close the SAM connection."""
        sleep(0.01)
        self.sock.close()
        self.connected = False

    def _recv(self):
        """Read data from SAM and add it to the buffer."""
        data = self.sock.recv(100000)
        self.logger.debug("Receiving data from SAM, length %d", len(data))
        if data == '':
            self._disconnect()
        else:
            self.samBuffer.add(data)
               

    def _send(self, message):
        """Add a message to the out buffer."""
        self.outBuffer.append(message)

    def _sendHandshake(self):
        self._send("HELLO VERSION MIN=%s MAX=%s\n" % (self.version, self.version))
        self.wantCommand = True

    def _sendClose(self, id):
        self._send("STREAM CLOSE ID=%d\n" % id)

    def _sendConnect(self, id, dest):
        self._send("STREAM CONNECT ID=%d DESTINATION=%s\n" % (id, dest))

    def _sendData(self, id, msg):
        self._send("STREAM SEND ID=%d SIZE=%d\n%s" % (id, len(msg), msg))

    def _sendBuffer(self):
        """Now really send the buffer"""
        try:
            while self.outBuffer != []:
                self.logger.debug("Sending data to SAM, length %d", len(self.outBuffer[0]))
                amount = self.sock.send(self.outBuffer[0])
                if amount != len(self.outBuffer[0]):
                    if amount != 0:
                        self.outBuffer[0] = self.outBuffer[0][amount:]
                    break
                del self.outBuffer[0]
        except socket.error, e:
            code, msg = e
            if code != EWOULDBLOCK:
                self.logger.error("SAM connection error %d: %s", code, msg)
                return

    def _on_message(self, msg, kwargs, data):
        """Call the proper _on_* handler"""
        #print msg, kwargs
        name = '_on_' + msg.upper().replace(' ', '_')
        getattr(self, name)(kwargs, data)

    def _on_HELLO_REPLY(self, kwargs, data):
        self.handshaked = True
       
        tunnel_parameters = ' inbound.nickname=%s outbound.nickname=%s' % (self.sessionname, self.sessionname)
        if self.tunnel_depth:
            tunnel_parameters += ' inbound.length=%s' % self.tunnel_depth
            tunnel_parameters += ' outbound.length=%s' % self.tunnel_depth
        if self.tunnel_number:
            tunnel_parameters += ' inbound.quantity=%s' % self.tunnel_number
            tunnel_parameters += ' outbound.quantity=%s' % self.tunnel_number
        if self.length_variance:
            tunnel_parameters += ' inbound.lengthVariance=%s' % self.length_variance
            tunnel_parameters += ' outbound.lengthVariance=%s' % self.length_variance
           
        self._send("SESSION CREATE STYLE=STREAM DESTINATION=%s DIRECTION=BOTH%s\n"
            % (self.sessionname, tunnel_parameters))

    def _on_SESSION_STATUS(self, kwargs, data):
        if not self.bound:
            self.bound = True
            # Look up your destination
            self._send("NAMING LOOKUP NAME=ME\n")

    def _on_NAMING_REPLY(self, kwargs, data):
        if not self.mydest and kwargs['RESULT'] == 'OK' and kwargs['NAME'] == 'ME':
            self.mydest = kwargs['VALUE'] + '.i2p'
        else:
            print "Huh, what did we ask?"

    def _on_STREAM_CONNECTED(self, kwargs, data):
        id = int(kwargs['ID'])
        dest= kwargs['DESTINATION']
        self.logger.debug("Inbound connection at %d from %s", id, dest)
        s = SingleSocket(self, (id, dest), self.handler, self.logger)
        s.connect()
        self.single_sockets[id] = s
        self.handler.external_connection_made(s)

    def _on_STREAM_RECEIVED(self, kwargs, data):
        id = int(kwargs['ID'])
        if self.single_sockets.has_key(id):
            self.logger.debug("Received data for %d, length %d", id, len(data))
            s = self.single_sockets.get(id)
            s.last_hit = time()
            s.handler.data_came_in(s, data)
        else:
            self.logger.debug("Connection already went away (stream received) for %d", id)

    def _on_STREAM_CLOSED(self, kwargs, data):
        id = int(kwargs['ID'])
        if self.single_sockets.has_key(id):
            self.logger.debug("Connection with %d closed", id)
            s = self.single_sockets[id]
            self._close_socket(s)
        else:
            self.logger.debug("Connection already went away (stream closed) for %d", id)

    def _on_STREAM_STATUS(self, kwargs, data):
        id = int(kwargs['ID'])
        if self.single_sockets.has_key(id):
            s = self.single_sockets.get(id)
            if kwargs['RESULT'] == 'OK':
                self.logger.debug("Outbound connection to %d established", id)
                s.connect()
            else:
                self.logger.debug("Outbound connection to %d failed %s", id, kwargs['RESULT'])
                self._close_socket(s)
        else:
            self.logger.debug("Connection already went away (stream status) for %d", id)

    def add_task(self, func, delay):
        self.unscheduled_tasks.append((func, delay))

    def scan_for_timeouts(self):
        self.add_task(self.scan_for_timeouts, self.timeout_check_interval)
        t = time() - self.timeout
        tokill = []
        for s in self.single_sockets.values():
            if s.last_hit < t:
                tokill.append(s)
        for k in tokill:
            self.logger.debug("Connection with %d closing due to timeout", k.id)
            k.close()

    def bind(self, port = '', reuse = False):
        """Specify the sessionname return the destination. blocks evily"""

        self.logger = Logger.Logger(self.sessionname)
        self.logger.info("Binding to '%s'", self.sessionname)

        while self.mydest == None:
            self.loopOnce()

        self.logger.info("Bound on %s", self.mydest)
        return self.mydest

    def start_connection(self, dns, handler = None):
        """Connect to a remote location. Returns a SingleSocket"""
        if handler == None:
            handler = self.handler
        self.maxId += 1
        # ignore the port
        dest = dns[0]
        # Remove Azureus style .i2p
        if len(dest) >= 256 and dest[-4:] == '.i2p':
            dest = dest[:-4]
        self.logger.debug("Connecting on %d to %s", self.maxId, dest)
        self._sendConnect(self.maxId, dest)
        s = SingleSocket(self, (self.maxId, dest), self.handler, self.logger)
        self.single_sockets[self.maxId] = s
        s.connect()
        return s

    def loopOnce(self, timeout=1.0):
        """Do a single poll loop"""
        sock = self.sock

        # check if there is data
        if self.outBuffer != [] or not self.connected:
            r = [sock]
            w = [sock]
            e = [sock]
        else:
            r = [sock]
            w = []
            e = [sock]

        # see http://mail.python.org/pipermail/python-dev/2000-October/009671.html
        while True:
            try:
                (R, W, E) = select.select(r, w, e, timeout)
            except select.error, v:
                if v[0] != EINTR:
                    raise
            else:
                break

        if sock in R:
            # receive incoming data
            self._recv()
        if sock in W:
            # initiate handshake upon connection
            if not self.connected:
                self.connected = True
                self._sendHandshake()
            # sending buffer to SAM
            self._sendBuffer()
        if sock in E:
            self.logger.error("SAM connection error")

        # handle messages
        for m, a, d in self.samBuffer.getMessages():
            self._on_message(m, a, d)

        # look if some socket has something to write
        for s in self.single_sockets.values():
            if s.connected and not s.is_flushed():
                s.try_write()
                if s.is_flushed():
                    s.handler.connection_flushed(s)

    def pop_unscheduled(self):
        try:
            while True:
                (func, delay) = self.unscheduled_tasks.pop()
                insort(self.funcs, (time() + delay, func))
        except IndexError:
            pass

    def listen_forever(self, handler):
        self.handler = handler
        try:
            while not self.doneflag.isSet():
                try:
                    self.pop_unscheduled()
                    if len(self.funcs) == 0:
                        period = 2 ** 30
                    else:
                        period = self.funcs[0][0] - time()
                    if period < 0:
                        period = 0
       
                    # network stuff
                    self.loopOnce(period)

                    # handle events
                    while len(self.funcs) > 0 and self.funcs[0][0] <= time():
                        garbage, func = self.funcs[0]
                        del self.funcs[0]
                        func()
                    #self._close_dead()
                    #self.handle_events(events)
                    #if self.doneflag.isSet():
                    #    return
                    #self._close_dead()
                except KeyboardInterrupt:
                    print_exc()
                    return

        finally:
#            for ss in self.single_sockets.values():
#                ss.close()
            self._disconnect()

    def _close_dead(self):
        while len(self.dead_from_write) > 0:
            old = self.dead_from_write
            self.dead_from_write = []
            for s in old:
                self._close_socket(s)

    def _close_socket(self, s):
        if s:
            id = s.id
            del self.single_sockets[id]
            s.connected = False

            # uncomment to dump the stack to the logs
            #data = StringIO()
            #print_stack(file = data)
            #self.logger.debug(data.getvalue())

            s.handler.connection_lost(s)
        else:
            self.logger.debug("Socket already went away (close_socket)")

class DummyHandler:
    def __init__(self):
        pass


def main():
    from threading import Event
    fa = Event()
    es = SamServer(fa, None, 100, 100)
    handler = DummyHandler()
    dest = es.bind(2134)
    print dest
    es.listen_forever(handler)

if __name__ == '__main__':
    main()


der downlaod oder die verbindugn geht so lange ich nicht bei
der 2 torrent die mit 108.4 rein klicke!
sonst ist es aus mit downlaoden und friert ein !

Bild
im status tab sehe ich garnichts und wenn ich den torrent drauf klcike friert es ja ein!

die fehler werden mir in cmd angezeigt!
Rufus requires wxwindows 2.5.2.8u
Installed wx version: 2.5.3.1
Loading config file: E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_
0.5.6_I2P\btconfig.ini
Loading Images E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_
I2P
Loading Friend List
ERROR: reading friends ini file
Loading RSS Feeds
ERROR: reading from RSS ini file
Loading config file: .\btconfig.ini
G3XMLRPCServer Started
loading work state
E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\torrents.in
i
from ini pt1.torrent
session 100 Adding torrent
False
Starting setup thread
starting dl setup
ending dl setup
trying to resume 100
Entered download thread
Starting download thread 100
check_hashes 1
reordering
2005-10-17 16:10:09,799 INFO: Binding to 'I2P-BT-636279575'
2005-10-17 16:10:12,783 INFO: Bound on W71KLCPD7m9hL5hSFoKOXue0T-bS8rKmbiqHQdGfc
a-eie7ymipYwvnkcKlFL30uyp~PdfkESBvqJG8lZUMCEW1J6PGoHOTAP-ngCuqkiHdLwcfjDqMYXX22y
mIX2y-gN97UmOBVBo0gHH5aAlZdhbOJUFkMYJxwMyM7of3D5ugAodYfEiUtGW1q9yioWsR2WrATycf9E
5S53n2YVmwpbZAfSpMnNEdpOtURRtNyyC3o4Q1wigNGBmnHS53STRh2Mm4JTBVNFFeRuXsFi~bRzjVOk
qFJXCUNR6Ck7yN4PGV6pIzSyKFRv4MkITsCE9SpV2miw6Vl5ofEqPOFWdiEHJFGv9qyyIrvGHXyStIEM
jfKi3803zQNwbgj61KqfSb73gUcHEUVZHiDcoswYwhFYlN7TG0s-xHh4l-v5y9nJv94HY6YMGpJMOQ84
1GcqrMeueLnv-ic3fxhAadbiT8TmOv3VsygfUvjjCePHpNpAJMwrjhnQLG1LpHbvfOa1~4dAAAA.i2p
Syncing Options
saving work state
saving options
announcing to http://YRgrgTLGnbTq2aZOZDJQ~o6Uk5k6TK-O ... RZioxqYG8A
Qt~LgyyI~NCj6aYWpPO-150RcEvsfgXLR~CxkkZcVpgt6pns8SRc3Bi-QSAkXpJtloapRGcQfzTtwllo
kbdC-aMGpeDOjYLd8b5V9Im8wdCHYy7LRFxhEtGb~RL55DA8aYOgEXcTpr6RPPywbV~Qf3q5UK55el6K
ex-6VCxreUnPEe4hmTAbqZNR7Fm0hpCiHKGoToRcygafpFqDw5frLXToYiqs9d4liyVB-BcOb0ihORbo
0nS3CLmAwZGvdAP8BZ7cIYE3Z9IU9D1G8JCMxWarfKX1pix~6pIA-sp1gKlL1HhYhPMxwyxvuSqx34o3
BqU7vdTYwWiLpGM~zU1~j9rHL7x60pVuYaXcFQDR4-QVy26b6Pt6BlAZoFmHhPcAuWfu-SFhjyZYsqzm
EmHeYdAwa~HojSbofg0TMUgESRXMw6YThK1KXWeeJVeztGTz25sL8AAAA.i2p/announce.php
http://YRgrgTLGnbTq2aZOZDJQ~o6Uk5k6TK-O ... gyyI~NCj6a
YWpPO-150RcEvsfgXLR~CxkkZcVpgt6pns8SRc3Bi-QSAkXpJtloapRGcQfzTtwllokbdC-aMGpeDOjY
Ld8b5V9Im8wdCHYy7LRFxhEtGb~RL55DA8aYOgEXcTpr6RPPywbV~Qf3q5UK55el6Kex-6VCxreUnPEe
4hmTAbqZNR7Fm0hpCiHKGoToRcygafpFqDw5frLXToYiqs9d4liyVB-BcOb0ihORbo0nS3CLmAwZGvdA
P8BZ7cIYE3Z9IU9D1G8JCMxWarfKX1pix~6pIA-sp1gKlL1HhYhPMxwyxvuSqx34o3BqU7vdTYwWiLpG
M~zU1~j9rHL7x60pVuYaXcFQDR4-QVy26b6Pt6BlAZoFmHhPcAuWfu-SFhjyZYsqzmEmHeYdAwa~HojS
bofg0TMUgESRXMw6YThK1KXWeeJVeztGTz25sL8AAAA.i2p/announce.php?info_hash=%3D%296%F
A%B3%D6%12w%EC%BE%84%3F%BB%A6%C4%D1%94%0Ex%EB&peer_id=%008RSAnonymous%C1%D94Kq%2
5%AB&port=6881&ip=W71KLCPD7m9hL5hSFoKOXue0T-bS8rKmbiqHQdGfca-eie7ymipYwvnkcKlFL3
0uyp%7EPdfkESBvqJG8lZUMCEW1J6PGoHOTAP-ngCuqkiHdLwcfjDqMYXX22ymIX2y-gN97UmOBVBo0g
HH5aAlZdhbOJUFkMYJxwMyM7of3D5ugAodYfEiUtGW1q9yioWsR2WrATycf9E5S53n2YVmwpbZAfSpMn
NEdpOtURRtNyyC3o4Q1wigNGBmnHS53STRh2Mm4JTBVNFFeRuXsFi%7EbRzjVOkqFJXCUNR6Ck7yN4PG
V6pIzSyKFRv4MkITsCE9SpV2miw6Vl5ofEqPOFWdiEHJFGv9qyyIrvGHXyStIEMjfKi3803zQNwbgj61
KqfSb73gUcHEUVZHiDcoswYwhFYlN7TG0s-xHh4l-v5y9nJv94HY6YMGpJMOQ841GcqrMeueLnv-ic3f
xhAadbiT8TmOv3VsygfUvjjCePHpNpAJMwrjhnQLG1LpHbvfOa1%7E4dAAAA.i2p&uploaded=0&down
loaded=0&left=100919318&event=started&key=ab25714b
E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\torrents.in
i
ERROR: urlopen(http://YRgrgTLGnbTq2aZOZDJQ~o6Uk5k6TK-O ... URZioxqYG8
AQt~LgyyI~NCj6aYWpPO-150RcEvsfgXLR~CxkkZcVpgt6pns8SRc3Bi-QSAkXpJtloapRGcQfzTtwll
okbdC-aMGpeDOjYLd8b5V9Im8wdCHYy7LRFxhEtGb~RL55DA8aYOgEXcTpr6RPPywbV~Qf3q5UK55el6
Kex-6VCxreUnPEe4hmTAbqZNR7Fm0hpCiHKGoToRcygafpFqDw5frLXToYiqs9d4liyVB-BcOb0ihORb
o0nS3CLmAwZGvdAP8BZ7cIYE3Z9IU9D1G8JCMxWarfKX1pix~6pIA-sp1gKlL1HhYhPMxwyxvuSqx34o
3BqU7vdTYwWiLpGM~zU1~j9rHL7x60pVuYaXcFQDR4-QVy26b6Pt6BlAZoFmHhPcAuWfu-SFhjyZYsqz
mEmHeYdAwa~HojSbofg0TMUgESRXMw6YThK1KXWeeJVeztGTz25sL8AAAA.i2p/scrape?info_hash=
%3D%296%FA%B3%D6%12w%EC%BE%84%3F%BB%A6%C4%D1%94%0Ex%EB) failed
<urlopen error (11001, 'getaddrinfo failed')>
<btsession.BTSession instance at 0x01B31558> False None
Traceback (most recent call last):
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\bts
ession.py", line 883, in Download_Thread
self.doneflag, 100, self.peer_id, spewflag = self.spewflag, onstartfunc = se
lf.OnStart)
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\download.py", line 456, in download
rawserver.listen_forever(encoder)
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\SamServer.py", line 379, in listen_forever
func()
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\DownloaderFeedback.py", line 152, in display
status['spew'] = self.collect_spew()
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\DownloaderFeedback.py", line 51, in collect_spew
rec["ip"], rec["port"] = c.get_address()
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\Connecter.py", line 50, in get_address
return self.connection.get_address()
File "E:\Bittorrent-I2P\bit-tests\Rufus_0.5.6_I2P_30.04.05\Rufus_0.5.6_I2P\Bit
Torrent\Encrypter.py", line 44, in get_address
return self.connection.get_address()
AttributeError: SingleSocket instance has no attribute 'get_address'
download thread finished 100


was kann ich tun?

hier ist mein source wenn mir jemand helfen kann das dieser crash nicht zu standen kommt?

http://rapidshare.de/files/6242487/Rufu ... 5.rar.html
matrixnet
User
Beiträge: 35
Registriert: Donnerstag 21. April 2005, 16:45

Beitragvon matrixnet » Montag 17. Oktober 2005, 17:58

hi ich habe den beitrag erstellt habe vergessen einzuloggen!

kann mir jemand weiterhelfen!?
Gast

Beitragvon Gast » Dienstag 18. Oktober 2005, 09:58

weis jemand ein rat? wie?
Benutzeravatar
jens
Moderator
Beiträge: 8458
Registriert: Dienstag 10. August 2004, 09:40
Wohnort: duisburg
Kontaktdaten:

Beitragvon jens » Dienstag 18. Oktober 2005, 10:22

Vielleicht wedest du dich besser an den Author des Skriptes ;)

CMS in Python: http://www.pylucid.org
GitHub | Open HUB | Xing | Linked in
Bitcoins to: 1JEgSQepxGjdprNedC9tXQWLpS424AL8cd
Gast

Beitragvon Gast » Donnerstag 20. Oktober 2005, 11:08

ja ich hatte schon kontakt mit ihm gehabt er hat aber keine zeit dafür!

Wer ist online?

Mitglieder in diesem Forum: Bing [Bot]