send file is now functional
This commit is contained in:
Dimitur Kirov
parent
053cbdcaeb
commit
e9daf09fe5
|
|
@ -141,6 +141,7 @@ class Connection:
|
|||
self.keep_alive_sent = False
|
||||
self.to_be_sent = []
|
||||
self.last_sent = []
|
||||
self.files_props = {}
|
||||
self.password = gajim.config.get_per('accounts', name, 'password')
|
||||
self.privacy_rules_supported = False
|
||||
if USE_GPG:
|
||||
|
|
@ -387,7 +388,7 @@ class Connection:
|
|||
file_props = gajim.socks5queue.get_file_props(
|
||||
self.name, sid)
|
||||
if file_props is None:
|
||||
return
|
||||
raise common.xmpp.NodeProcessed
|
||||
# todo - error
|
||||
streamhosts=[]
|
||||
for item in query.getChildren():
|
||||
|
|
@ -417,7 +418,21 @@ class Connection:
|
|||
stream_tag.setAttr('jid', streamhost['jid'])
|
||||
self.to_be_sent.append(iq)
|
||||
raise common.xmpp.NodeProcessed
|
||||
|
||||
|
||||
def _bytestreamResultCB(self, con, iq_obj):
|
||||
gajim.log.debug('_bytestreamResultCB')
|
||||
frm = str(iq_obj.getFrom())
|
||||
id = str(iq_obj.getAttr('id'))
|
||||
query = iq_obj.getTag('query')
|
||||
streamhost = query.getTag('streamhost-used')
|
||||
jid = streamhost.getAttr('jid')
|
||||
id = id[3:]
|
||||
if not self.files_props.has_key(id):
|
||||
return
|
||||
file_props = self.files_props[id]
|
||||
gajim.socks5queue.send_file(file_props, self.name)
|
||||
raise common.xmpp.NodeProcessed
|
||||
|
||||
def _discoGetCB(self, con, iq_obj):
|
||||
''' get disco info '''
|
||||
frm = str(iq_obj.getFrom())
|
||||
|
|
@ -442,7 +457,65 @@ class Connection:
|
|||
|
||||
self.to_be_sent.append(iq)
|
||||
raise common.xmpp.NodeProcessed
|
||||
|
||||
def _siResultCB(self, con, iq_obj):
|
||||
gajim.log.debug('_siResultCB')
|
||||
id = iq_obj.getAttr('id')
|
||||
if not self.files_props.has_key(id):
|
||||
return
|
||||
file_props = self.files_props[id]
|
||||
if file_props is None:
|
||||
return
|
||||
file_props['receiver'] = str(iq_obj.getFrom())
|
||||
jid = iq_obj.getFrom().getStripped().encode('utf8')
|
||||
si = iq_obj.getTag('si')
|
||||
feature = si.setTag('feature')
|
||||
if feature.getNamespace() != common.xmpp.NS_FEATURE:
|
||||
return
|
||||
form_tag = feature.getTag('x')
|
||||
form = common.xmpp.DataForm(node=form_tag)
|
||||
field = form.getField('stream-method')
|
||||
if field.getValue() != common.xmpp.NS_BYTESTREAM:
|
||||
return
|
||||
self.send_socks5_info(file_props)
|
||||
raise common.xmpp.NodeProcessed
|
||||
|
||||
def _get_sha(self, sid, initiator, target):
|
||||
import sha
|
||||
return sha.new("%s%s%s" % (sid, initiator, target)).hexdigest()
|
||||
|
||||
def result_socks5_sid(self, sid, hash_id):
|
||||
if not self.files_props.has_key(sid):
|
||||
return
|
||||
file_props = self.files_props[sid]
|
||||
file_props['hash'] = hash_id
|
||||
return
|
||||
|
||||
def send_socks5_info(self, file_props):
|
||||
if type(self.peerhost) != tuple:
|
||||
return
|
||||
port = 8011
|
||||
sha_str = self._get_sha(file_props['sid'], file_props['sender'],
|
||||
file_props['receiver'])
|
||||
file_props['sha_str'] = sha_str
|
||||
listener = gajim.socks5queue.start_listener(self.peerhost[0], port,
|
||||
sha_str, self.result_socks5_sid, file_props['sid'])
|
||||
if listener == None:
|
||||
return
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = str(file_props['receiver']),
|
||||
typ = 'set')
|
||||
file_props['request-id'] = 'id_' + file_props['sid']
|
||||
iq.setID(file_props['request-id'])
|
||||
query = iq.setTag('query')
|
||||
query.setNamespace(common.xmpp.NS_BYTESTREAM)
|
||||
query.setAttr('mode', 'tcp')
|
||||
query.setAttr('sid', file_props['sid'])
|
||||
streamhost = query.setTag('streamhost')
|
||||
streamhost.setAttr('port', str(port))
|
||||
streamhost.setAttr('host', self.peerhost[0])
|
||||
streamhost.setAttr('jid', str(file_props['sender']))
|
||||
self.to_be_sent.append(iq)
|
||||
|
||||
def _siSetCB(self, con, iq_obj):
|
||||
gajim.log.debug('_siSetCB')
|
||||
jid = iq_obj.getFrom().getStripped().encode('utf8')
|
||||
|
|
@ -453,7 +526,7 @@ class Connection:
|
|||
return
|
||||
feature = si.getTag('feature')
|
||||
file_tag = si.getTag('file')
|
||||
file_props = {'type':'r'}
|
||||
file_props = {'type' : 'r'}
|
||||
for attribute in file_tag.getAttrs():
|
||||
attribute = attribute.encode('utf-8')
|
||||
if attribute in ['name', 'size', 'hash', 'date']:
|
||||
|
|
@ -479,7 +552,7 @@ class Connection:
|
|||
|
||||
def send_file_rejection(self, file_props):
|
||||
''' informs sender that we refuse to download the file '''
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = str(file_props['sender']), \
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = str(file_props['sender']),
|
||||
typ = 'error')
|
||||
iq.setAttr('id', file_props['request-id'])
|
||||
err = common.xmpp.ErrorNode(code = '406', typ = 'auth', name = 'not-acceptable')
|
||||
|
|
@ -488,7 +561,7 @@ class Connection:
|
|||
|
||||
def send_file_approval(self, file_props):
|
||||
''' comfirm that we want to download the file '''
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = str(file_props['sender']), \
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = str(file_props['sender']),
|
||||
typ = 'result')
|
||||
iq.setAttr('id', file_props['request-id'])
|
||||
si = iq.setTag('si')
|
||||
|
|
@ -504,6 +577,38 @@ class Connection:
|
|||
field.setValue('http://jabber.org/protocol/bytestreams')
|
||||
self.to_be_sent.append(iq)
|
||||
|
||||
def send_file_request(self, file_props):
|
||||
name = gajim.config.get_per('accounts', self.name, 'name')
|
||||
hostname = gajim.config.get_per('accounts', self.name, 'hostname')
|
||||
resource = gajim.config.get_per('accounts', self.name, 'resource')
|
||||
frm = name + '@' + hostname + '/' + resource
|
||||
file_props['sender'] = frm
|
||||
fjid = file_props['receiver'].jid + '/' + file_props['receiver'].resource
|
||||
iq = common.xmpp.Protocol(name = 'iq', to = fjid,
|
||||
typ = 'set')
|
||||
iq.setID(file_props['sid'])
|
||||
self.files_props[file_props['sid']] = file_props
|
||||
si = iq.setTag('si')
|
||||
si.setNamespace(common.xmpp.NS_SI)
|
||||
si.setAttr('profile', common.xmpp.NS_FILE)
|
||||
si.setAttr('id', file_props['sid'])
|
||||
file_tag = si.setTag('file')
|
||||
file_tag.setNamespace(common.xmpp.NS_FILE)
|
||||
file_tag.setAttr('name', file_props['name'])
|
||||
file_tag.setAttr('size', file_props['size'])
|
||||
desc = file_tag.setTag('desc')
|
||||
if file_props.has_key('desc'):
|
||||
desc.setData(file_props['desc'])
|
||||
file_tag.setTag('range')
|
||||
feature = si.setTag('feature')
|
||||
feature.setNamespace(common.xmpp.NS_FEATURE)
|
||||
_feature = common.xmpp.DataForm(typ='form')
|
||||
feature.addChild(node=_feature)
|
||||
field = _feature.setField('stream-method')
|
||||
field.setAttr('type', 'list-single')
|
||||
field.addOption('http://jabber.org/protocol/bytestreams')
|
||||
self.to_be_sent.append(iq)
|
||||
|
||||
def _rosterSetCB(self, con, iq_obj):
|
||||
gajim.log.debug('rosterSetCB')
|
||||
for item in iq_obj.getTag('query').getChildren():
|
||||
|
|
@ -851,10 +956,14 @@ class Connection:
|
|||
common.xmpp.NS_ROSTER)
|
||||
con.RegisterHandler('iq', self._siSetCB, 'set',
|
||||
common.xmpp.NS_SI)
|
||||
con.RegisterHandler('iq', self._siResultCB, 'result',
|
||||
common.xmpp.NS_SI)
|
||||
con.RegisterHandler('iq', self._discoGetCB, 'get',
|
||||
common.xmpp.NS_DISCO)
|
||||
con.RegisterHandler('iq', self._bytestreamSetCB, 'set',
|
||||
common.xmpp.NS_BYTESTREAM)
|
||||
con.RegisterHandler('iq', self._bytestreamResultCB, 'result',
|
||||
common.xmpp.NS_BYTESTREAM)
|
||||
con.RegisterHandler('iq', self._BrowseResultCB, 'result',
|
||||
common.xmpp.NS_BROWSE)
|
||||
con.RegisterHandler('iq', self._DiscoverItemsCB, 'result',
|
||||
|
|
|
|||
|
|
@ -35,12 +35,32 @@ class SocksQueue:
|
|||
self.connected = 0
|
||||
self.readers = {}
|
||||
self.files_props = {}
|
||||
self.senders = {}
|
||||
self.idx = 0
|
||||
self.listener = None
|
||||
self.sha_handlers = {}
|
||||
self.complete_transfer_cb = complete_transfer_cb
|
||||
self.progress_transfer_cb = progress_transfer_cb
|
||||
|
||||
def start_listener(self):
|
||||
Socks5Sender()
|
||||
def start_listener(self, host, port, sha_str, sha_handler, sid):
|
||||
self.sha_handlers[sha_str] = (sha_handler, sid)
|
||||
if self.listener == None:
|
||||
self.listener = Socks5Listener(host, port)
|
||||
self.listener.bind()
|
||||
self.connected += 1
|
||||
return self.listener
|
||||
|
||||
def result_sha(self, sha_str, idx):
|
||||
if self.sha_handlers.has_key(sha_str):
|
||||
props = self.sha_handlers[sha_str]
|
||||
props[0](props[1], idx)
|
||||
|
||||
def send_file(self, file_props, account):
|
||||
if self.senders.has_key(file_props['hash']):
|
||||
sender = self.senders[file_props['hash']]
|
||||
sender.account = account
|
||||
result = sender.send_file(file_props)
|
||||
self.process_result(result, sender)
|
||||
|
||||
def add_receiver(self, account, sock5_receiver):
|
||||
''' add new file request '''
|
||||
|
|
@ -68,12 +88,39 @@ class SocksQueue:
|
|||
def get_file_props(self, account, id):
|
||||
if self.files_props.has_key(account):
|
||||
fl_props = self.files_props[account]
|
||||
if fl_props.has_key(id):
|
||||
return fl_props[id]
|
||||
if fl_props.has_key(id):
|
||||
return fl_props[id]
|
||||
return None
|
||||
|
||||
def process(self, timeout=0):
|
||||
''' process all file requests '''
|
||||
if self.listener is not None:
|
||||
if self.listener.pending_connection():
|
||||
_sock = self.listener.accept_conn()
|
||||
sock_hash = _sock.__hash__()
|
||||
if not self.senders.has_key(sock_hash):
|
||||
self.senders[sock_hash] = Socks5Sender(sock_hash, self,
|
||||
_sock[0], _sock[1][0], _sock[1][1])
|
||||
self.connected += 1
|
||||
|
||||
for idx in self.senders.keys():
|
||||
sender = self.senders[idx]
|
||||
if sender.connected:
|
||||
if sender.state == 1:
|
||||
if sender.pending_data():
|
||||
result = sender.get_data()
|
||||
if result is not None:
|
||||
sender.state = 2
|
||||
self.result_sha(result, idx)
|
||||
else:
|
||||
sender.disconnect()
|
||||
elif sender.state == 3:
|
||||
result = sender.write_next()
|
||||
self.process_result(result, sender)
|
||||
elif sender.state == 4:
|
||||
self.remove_sender(idx)
|
||||
else:
|
||||
self.remove_sender(idx)
|
||||
for idx in self.readers.keys():
|
||||
receiver = self.readers[idx]
|
||||
if receiver.connected:
|
||||
|
|
@ -81,27 +128,36 @@ class SocksQueue:
|
|||
continue
|
||||
if receiver.pending_data():
|
||||
result = receiver.get_file_contents(timeout)
|
||||
if result in [0, -1] and \
|
||||
self.complete_transfer_cb is not None:
|
||||
self.complete_transfer_cb(receiver.account,
|
||||
receiver.file_props)
|
||||
|
||||
elif self.progress_transfer_cb is not None:
|
||||
self.progress_transfer_cb(receiver.account,
|
||||
receiver.file_props)
|
||||
self.process_result(result, receiver)
|
||||
else:
|
||||
self.remove_receiver(idx)
|
||||
|
||||
def process_result(self, result, actor):
|
||||
if result in [0, -1] and \
|
||||
self.complete_transfer_cb is not None:
|
||||
self.complete_transfer_cb(actor.account,
|
||||
actor.file_props)
|
||||
elif self.progress_transfer_cb is not None:
|
||||
self.progress_transfer_cb(actor.account,
|
||||
actor.file_props)
|
||||
|
||||
def remove_receiver(self, idx):
|
||||
if idx != -1:
|
||||
if self.readers.has_key(idx):
|
||||
del(self.readers[idx])
|
||||
if self.connected > 0:
|
||||
self.connected -= 1
|
||||
def remove_sender(self, idx):
|
||||
if idx != -1:
|
||||
if self.senders.has_key(idx):
|
||||
del(self.senders[idx])
|
||||
if self.connected > 0:
|
||||
self.connected -= 1
|
||||
|
||||
class Socks5:
|
||||
def __init__(self, host, port, initiator, target, sid):
|
||||
self.host = socket.gethostbyname(host)
|
||||
if host is not None:
|
||||
self.host = socket.gethostbyname(host)
|
||||
self.port = port
|
||||
self.initiator = initiator
|
||||
self.target = target
|
||||
|
|
@ -134,7 +190,6 @@ class Socks5:
|
|||
received +=add
|
||||
if not add:
|
||||
break
|
||||
|
||||
if len(received) == 0:
|
||||
self.disconnect()
|
||||
return received
|
||||
|
|
@ -150,8 +205,6 @@ class Socks5:
|
|||
|
||||
def disconnect(self):
|
||||
''' Closes the socket. '''
|
||||
if 'fcntl' in globals():
|
||||
fcntl.fcntl(self._sock, fcntl.F_SETFL, 0);
|
||||
self._sock.close()
|
||||
self.connected = False
|
||||
|
||||
|
|
@ -181,20 +234,18 @@ class Socks5:
|
|||
if version != 0x05 or method == 0xff:
|
||||
self.disconnect()
|
||||
return None
|
||||
self.send_raw(self._get_request_buff())
|
||||
self.send_raw(self._get_request_buff(self._get_sha1_auth()))
|
||||
buff = self.receive()
|
||||
version, command, rsvd, address_type = struct.unpack('!BBBB', buff[:4])
|
||||
addrlen, address, port = 0, 0, 0
|
||||
if address_type == 0x03:
|
||||
addrlen = ord(buff[4])
|
||||
address = struct.unpack('!%ds' % addrlen, buff[5:addrlen+5])
|
||||
|
||||
portlen = len(buff[addrlen+5])
|
||||
address = struct.unpack('!%ds' % addrlen, buff[5:addrlen + 5])
|
||||
portlen = len(buff[addrlen + 5])
|
||||
if portlen == 1: # Gaim bug :)
|
||||
(port) = struct.unpack('!B', buff[addrlen+5])
|
||||
port, = struct.unpack('!B', buff[addrlen + 5])
|
||||
else:
|
||||
(port) = struct.unpack('!H', buff[addrlen+5])
|
||||
|
||||
port, = struct.unpack('!H', buff[addrlen + 5])
|
||||
return (version, command, rsvd, address_type, addrlen, address, port)
|
||||
|
||||
|
||||
|
|
@ -202,7 +253,19 @@ class Socks5:
|
|||
''' Message, that we support 1 one auth mechanism:
|
||||
the 'no auth' mechanism. '''
|
||||
return struct.pack('!BBB', 0x05, 0x01, 0x00)
|
||||
|
||||
|
||||
def _parse_auth_buff(self, buff):
|
||||
''' Parse the initial message and create a list of auth
|
||||
mechanisms '''
|
||||
auth_mechanisms = []
|
||||
ver, num_auth = struct.unpack('!BB', buff[:2])
|
||||
for i in range(num_auth):
|
||||
mechanism, = struct.unpack('!B', buff[1 + i])
|
||||
auth_mechanisms.append(mechanism)
|
||||
return auth_mechanisms
|
||||
def _get_auth_response(self):
|
||||
return struct.pack('!BB', 0x05, 0x00)
|
||||
|
||||
def _get_connect_buff(self):
|
||||
''' Connect request by domain name '''
|
||||
buff = struct.pack('!BBBBB%dsBB' % len(self.host), \
|
||||
|
|
@ -210,14 +273,32 @@ class Socks5:
|
|||
self.port >> 8, self.port & 0xff)
|
||||
return buff
|
||||
|
||||
def _get_request_buff(self):
|
||||
def _get_request_buff(self, msg, command = 0x01):
|
||||
''' Connect request by domain name,
|
||||
sid sha, instead of domain name (jep 0096) '''
|
||||
msg = self._get_sha1_auth()
|
||||
#~ msg = self._get_sha1_auth()
|
||||
buff = struct.pack('!BBBBB%dsBB' % len(msg), \
|
||||
0x05, 0x01, 0x00, 0x03, len(msg), msg, 0, 0)
|
||||
0x05, command, 0x00, 0x03, len(msg), msg, 0, 0)
|
||||
return buff
|
||||
|
||||
|
||||
def _parse_request_buff(self, buff):
|
||||
version, req_type, reserved, host_type, = \
|
||||
struct.unpack('!BBBB', buff[:4])
|
||||
if host_type == 0x01:
|
||||
host_arr = struct.unpack('!iiii', buff[4:8])
|
||||
host, = reduce(lambda e1, e2: str(e1) + "." + str(e2), host_arr)
|
||||
host_len = len(host)
|
||||
elif host_type == 0x03:
|
||||
host_len, = struct.unpack('!B' , buff[4])
|
||||
host, = struct.unpack('!%ds' % host_len, buff[5:5 + host_len])
|
||||
portlen = len(buff[host_len + 5])
|
||||
if portlen == 1: # Gaim bug :)
|
||||
port, = struct.unpack('!B', buff[host_len + 5])
|
||||
else:
|
||||
port, = struct.unpack('!H', buff[host_len + 5])
|
||||
return (req_type, host, port)
|
||||
|
||||
|
||||
def read_connect(self):
|
||||
buff = self._recv()
|
||||
version, method = struct.unpack('!BB', buff)
|
||||
|
|
@ -227,32 +308,166 @@ class Socks5:
|
|||
|
||||
def _get_sha1_auth(self):
|
||||
return sha.new("%s%s%s" % (self.sid, self.initiator, self.target)).hexdigest()
|
||||
class Socks5Sender(Socks5):
|
||||
def __init__(self, sock_hash, parent, _sock, host = None, port = None):
|
||||
self.queue_idx = sock_hash
|
||||
self.queue = parent
|
||||
Socks5.__init__(self, host, port, None, None, None)
|
||||
self._sock = _sock
|
||||
self._recv = _sock.recv
|
||||
self._send = _sock.send
|
||||
self.connected = True
|
||||
self.state = 1 # waiting for first bytes
|
||||
self.file_props = None
|
||||
self.remaining_buff = ''
|
||||
|
||||
def write_next(self):
|
||||
send_size = 65536
|
||||
if self.remaining_buff != '':
|
||||
buff = self.remaining_buff
|
||||
self.remaining_buff = ''
|
||||
else:
|
||||
buff = self.fd.read(send_size)
|
||||
if len(buff) > 0:
|
||||
lenn = 0
|
||||
try:
|
||||
lenn = self._send(buff)
|
||||
except Exception, e:
|
||||
if e.args[0] != 11:
|
||||
self.state = 4
|
||||
self.fd.close()
|
||||
self.disconnect()
|
||||
return -1
|
||||
self.size += lenn
|
||||
self.file_props['received-len'] = self.size
|
||||
if self.size == int(self.file_props['size']):
|
||||
self.state = 4
|
||||
self.fd.close()
|
||||
self.disconnect()
|
||||
return -1
|
||||
if lenn != len(buff):
|
||||
self.remaining_buff = buff[lenn:]
|
||||
else:
|
||||
self.remaining_buff = ''
|
||||
if lenn == 0:
|
||||
self.pauses +=1
|
||||
else:
|
||||
self.pauses = 0
|
||||
if self.pauses > 20:
|
||||
self.file_props['paused'] = True
|
||||
else:
|
||||
self.file_props['paused'] = False
|
||||
return lenn
|
||||
else:
|
||||
self.state = 4
|
||||
self.disconnect()
|
||||
return -1
|
||||
|
||||
def send_file(self, file_props):
|
||||
self.fd = open(file_props['file-name'])
|
||||
file_props['error'] = 0
|
||||
file_props['disconnect_cb'] = self.disconnect
|
||||
file_props['started'] = True
|
||||
file_props['completed'] = False
|
||||
file_props['paused'] = False
|
||||
self.pauses = 0
|
||||
self.file_props = file_props
|
||||
self.size = 0
|
||||
self.state = 3
|
||||
self._sock.setblocking(False)
|
||||
|
||||
return self.write_next()
|
||||
|
||||
def get_data(self):
|
||||
if self.state == 1:
|
||||
buff = self.receive()
|
||||
if not self.connected:
|
||||
return -1
|
||||
mechs = self._parse_auth_buff(buff)
|
||||
self._sock.setblocking(True)
|
||||
self.send_raw(self._get_auth_response())
|
||||
|
||||
buff = self.receive()
|
||||
|
||||
(req_type, sha_msg, port) = self._parse_request_buff(buff)
|
||||
self.send_raw(self._get_request_buff(sha_msg, 0x00))
|
||||
self.state = 2
|
||||
self._sock.setblocking(False)
|
||||
return sha_msg
|
||||
return None
|
||||
|
||||
def pending_data(self,timeout=0):
|
||||
''' Returns true if there is a data ready to be read. '''
|
||||
if self._sock is None:
|
||||
return False
|
||||
try:
|
||||
if self.state == 1:
|
||||
return select.select([self._sock],[],[],timeout)[0]
|
||||
elif self.state == 3:
|
||||
return select.select([],[self._sock],[],timeout)[0]
|
||||
except Exception, e:
|
||||
return False
|
||||
return False
|
||||
|
||||
def disconnect(self):
|
||||
''' Closes the socket. '''
|
||||
# close connection and remove us from the queue
|
||||
self._sock.close()
|
||||
self.connected = False
|
||||
self.file_props['disconnect_cb'] = None
|
||||
if self.queue is not None:
|
||||
self.queue.remove_sender(self.queue_idx)
|
||||
|
||||
|
||||
class Socks5Listener:
|
||||
def __init__(self, host, port):
|
||||
self.host, self.port
|
||||
self.host, self.port = host, port
|
||||
self.queue_idx = -1
|
||||
self.queue = None
|
||||
self.started = False
|
||||
self._sock = None
|
||||
|
||||
def bind(self):
|
||||
self._serv=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self._serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
self._serv.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
|
||||
self._serv.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
|
||||
self._serv.bind((self.host, self.port))
|
||||
self._serv.listen(socket.SOMAXCONN)
|
||||
self.connected = False
|
||||
|
||||
def bind(self):
|
||||
self._serv=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
self._serv.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
||||
self._serv.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
|
||||
self._serv.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
|
||||
self._serv.bind((self.host, self.port))
|
||||
self._serv.listen(socket.SOMAXCONN)
|
||||
self._serv.setblocking(False)
|
||||
self.started = True
|
||||
|
||||
def accept_conn(self):
|
||||
self._serv.accept.__doc__
|
||||
_sock = self._serv.accept()
|
||||
# block it untill authorization is sent
|
||||
_sock[0].setblocking(True)
|
||||
return _sock
|
||||
|
||||
def pending_connection(self,timeout=0):
|
||||
''' Returns true if there is a data ready to be read. '''
|
||||
if self._serv is None:
|
||||
return False
|
||||
try:
|
||||
res = select.select([self._serv],[],[],timeout)
|
||||
return res[0]
|
||||
except Exception, e:
|
||||
self.file_props['started'] = True
|
||||
return False
|
||||
|
||||
class Socks5Receiver(Socks5):
|
||||
def __init__(self, host, port, initiator, target, sid, file_props = None):
|
||||
self.queue_idx = -1
|
||||
self.queue = None
|
||||
self.file_props = file_props
|
||||
self.file_props['started'] = True
|
||||
if file_props:
|
||||
file_props['disconnect_cb'] = self.disconnect
|
||||
file_props['error'] = 0
|
||||
self.file_props['started'] = True
|
||||
self.file_props['completed'] = False
|
||||
self.file_props['paused'] = False
|
||||
self.file_props['started'] = True
|
||||
Socks5.__init__(self, host, port, initiator, target, sid)
|
||||
|
||||
def get_file_contents(self, timeout):
|
||||
|
|
@ -301,8 +516,6 @@ class Socks5Receiver(Socks5):
|
|||
def disconnect(self):
|
||||
''' Closes the socket. '''
|
||||
# close connection and remove us from the queue
|
||||
if 'fcntl' in globals():
|
||||
fcntl.fcntl(self._sock, fcntl.F_SETFL, 0);
|
||||
self._sock.close()
|
||||
self.connected = False
|
||||
self.file_props['disconnect_cb'] = None
|
||||
|
|
|
|||
|
|
@ -71,6 +71,7 @@ NS_FILE ='http://jabber.org/protocol/si/profile/file-transfer' # JEP-009
|
|||
NS_FEATURE ='http://jabber.org/protocol/feature-neg'
|
||||
NS_BYTESTREAM ='http://jabber.org/protocol/bytestreams' # JEP-0065
|
||||
NS_DISCO ='http://jabber.org/protocol/disco#info' # JEP-0095
|
||||
NS_STREAM ='http://affinix.com/jabber/stream'
|
||||
|
||||
xmpp_stream_error_conditions="""
|
||||
bad-format -- -- -- The entity has sent XML that cannot be processed.
|
||||
|
|
|
|||
Loading…
Reference in New Issue