Basic Network Programming (Python on Symbian)

selective

 
Network: 10.0.0.0
Mask: 255.255.255.0 or /24 (CIDR notation)
IP addresses range: 10.0.0.1 to 10.0.0.254 (to be used in your machines)
Broadcast: 10.0.0.255
 
 
Network: 200.201.145.128
Mask: 255.255.255.192 or /26 (CIDR notation)
 
 
Mask: 255.255.255.192 or /26 (CIDR notation)
Broadcast: 200.201.145.191
IP addresses range: 200.201.145.129 to 200.201.145.190 (to be used in your machines)
 
 
# Fortune client
 
from socket import *
 
HOST = "10.0.0.100"
PORT = 54321
 
s = socket(AF_INET,SOCK_STREAM)
s.connect((HOST,PORT))
 
fortune = u""
while True:
    data = s.recv(1024)
    if not data:
        break
    fortune += data
 
s.close()
 
from appuifw import note
note(fortune,"info")
 
 
# Fortune server
 
from socket import *
from random import choice
 
# Fortune database from The Zen of Python, by Tim Peters (import this)
PHRASES =[ u"Beautiful is better than ugly.",
           u"Explicit is better than implicit.",
           u"Simple is better than complex.",
           u"Complex is better than complicated.",
           u"Flat is better than nested.",
           u"Sparse is better than dense.",
           u"Readability counts.",
           u"Special cases aren't special enough to break the rules.",
           u"Although practicality beats purity.",
           u"Errors should never pass silently.",
           u"Unless explicitly silenced.",
           u"In the face of ambiguity, refuse the temptation to guess.",
           u"There should be one-- and preferably only one --obvious way to do it.",
           u"Although that way may not be obvious at first unless you're Dutch.",
           u"Now is better than never.",
           u"Although never is often better than *right* now.",
           u"If the implementation is hard to explain, it's a bad idea.",
           u"If the implementation is easy to explain, it may be a good idea.",
           u"Namespaces are one honking great idea -- let's do more of those!" ]
 
HOST = "10.0.0.100"
PORT = 54321
 
s = socket(AF_INET,SOCK_STREAM)
s.bind((HOST,PORT))
s.listen(5)
 
while True:
    (cs,addr) = s.accept()
    fortune = choice(PHRASES)
    cs.sendall(fortune)
    cs.close()
 
>>> import btsocket
>>> api=btsocket.select_access_point()
>>> print api
8
>>> apo = btsocket.access_point(api)
>>> btsocket.set_default_access_point(apo)

>>> dir(apo)
['ip', 'start', 'stop']

 
# -*- coding: utf-8 -*-
import sys
from appuifw import *
 
try:
    # http://discussion.forum.nokia.com/forum/showthread.php?p=575213
    # Try to import 'btsocket' as 'socket' (just for 1.9.x)
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
 
import socket
 
def sel_access_point():
    """ Select the default access point.
        Return True if the selection was done or False if not
    """
    aps = socket.access_points()
    if not aps:
        note(u"No access points available","error")
        return False
 
    ap_labels = map(lambda x: x['name'], aps)
    item = popup_menu(ap_labels,u"Access points:")
    if item is None:
        return False
 
    apo = socket.access_point(aps[item]['iapid'])
    socket.set_default_access_point(apo)
 
    return True
 
 
# -*- coding: utf-8 -*-
import sys
try:
    # http://discussion.forum.nokia.com/forum/showthread.php?p=575213
    # Try to import 'btsocket' as 'socket' - ignored on versions &lt; 1.9.x
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
 
from appuifw import *
import socket
import os
import e32
import struct
 
class FileUpload(object):
    """ File upload server class
    """
    def __init__(self):
        self.lock = e32.Ao_lock()
        self.dir = "e:\\file_upload"
        if not os.path.isdir(self.dir):
            os.makedirs(self.dir)
        self.apo = None
        self.port = 54321
        self.new_line = u"\u2029"
        app.title = u"File upload"
        app.screen = "normal"
        app.menu = [(u"About", self.about)]
        self.body = Text()
        app.body = self.body
        self.lock = e32.Ao_lock()
 
    def recv_file(self,cs,addr):
        """ Given a client socket (cs), receive a new file
            and save it at self.dir
        """
        data = ""
        name = ""
        size = 0
        # waiting for file name
        while True:
            n = data.find("\n")
            if n >= 0:
                name = data[:n]
                data = data[n+1:]
                break
            buf = cs.recv(1024)
            data += buf
 
        # waiting for file size (may be useful for limits checking)
        while True:
            n = data.find("\n")
            if n >= 0:
                # unpack one long (L) using big endian (>) endianness
                size = struct.unpack(">L",data[:n])[0]
                data = data[n+1:]
                break
            buf = cs.recv(1024)
            data += buf
 
        self.body.add(u"Uploading %s (%d bytes)" % (name,size) + self.new_line)
        # waiting for file contents
        fname = os.path.join(self.dir,name)
        f = open(fname,"wb")
        while True:
            f.write(data)
            data = cs.recv(1024)
            if not data:
                break
        self.body.add(u"Finished." + self.new_line)
        cs.close()
        f.close()
 
    def server(self,ip,port):
        """ Starts a mono thread server at ip, port
        """
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        s.bind((ip,port))
        s.listen(1)
 
        while True:
            (cs,addr) = s.accept()
            self.body.add(u"Connect to %s:%d" % (addr[0],addr[1]) + self.new_line)
            self.recv_file(cs,addr)
 
    def sel_access_point(self):
        """ Select and set the default access point.
            Return the access point object if the selection was done or None if not
        """
        aps = socket.access_points()
        if not aps:
            note(u"No access points available","error")
            return None
 
        ap_labels = map(lambda x: x['name'], aps)
        item = popup_menu(ap_labels,u"Access points:")
        if item is None:
            return None
 
        apo = socket.access_point(aps[item]['iapid'])
        socket.set_default_access_point(apo)
 
        return apo
 
    def about(self):
        note(u"File upload by Marcelo Barros (marcelobarrosalmeida@gmail.com)","info")
 
    def run(self):
        self.apo = self.sel_access_point()
        if self.apo:
            self.apo.start()
            self.body.add(u"Starting server." + self.new_line)
            self.body.add(u"IP = %s" % self.apo.ip() + self.new_line)
            self.body.add(u"Port = %d" % self.port + self.new_line)
            self.body.add(u"Repository = %s" % (self.dir) + self.new_line)
            self.server(self.apo.ip(),self.port)
            self.lock.wait()
        app.set_tabs( [], None )
        app.menu = []
        app.body = None
        app.set_exit()
 
if __name__ == "__main__":
    app = FileUpload()
    app.run()
 
 
# -*- coding: utf-8 -*-
import struct
import sys
import os
import socket
 
if len(sys.argv) &lt; 4:
    print "%s server_addr server_port file_to_upload" % sys.argv[0]
    sys.exit(1)
 
ip = sys.argv[1]
port = int(sys.argv[2])
full_name = sys.argv[3]
base_name = os.path.basename(full_name)
size = os.path.getsize(sys.argv[3])
 
print "Sending %s to %s:%d ..." % (base_name,ip,port)
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((ip,port))
f = open(full_name,"rb")
header = "%s\n%s\n" % (base_name,struct.pack(">L",size))
s.sendall(header)
while True:
    data = f.read(1024)
    if not data:
        break
    s.sendall(data)
 
s.close()
f.close()
 
 
# -*- coding: utf-8 -*-
 
import sys
try:
    # http://discussion.forum.nokia.com/forum/showthread.php?p=575213
    # Try to import 'btsocket' as 'socket' - ignored on versions < 1.9.x
    sys.modules['socket'] = __import__('btsocket')
except ImportError:
    pass
 
from appuifw import *
import socket
import os
import e32
import struct
 
class RxFile(object):
    """ RxFile server class
    """
    def __init__(self):
        self.lock = e32.Ao_lock()
        self.dir = "e:\\rxfile"
        if not os.path.isdir(self.dir):
            os.makedirs(self.dir)
        self.apo = None
        self.port = 54321            
        self.new_line = u"\u2029"
        app.title = u"RX File"
        app.screen = "normal"
        app.menu = [(u"About", self.about)]
        self.body = Text()
        app.body = self.body
        self.lock = e32.Ao_lock()
 
    def recv_file(self,cs,addr):
        """ Given a client socket (cs), receive a new file
            and save it at self.dir
        """
        data = ""
        name = ""
        size = 0
        # waiting for file name
        while True:
            n = data.find("\n")
            if n >= 0:
                name = data[:n]
                data = data[n+1:] 
                break
            try:
                buf = cs.recv(1024)
            except socket.error:
                cs.close()
                return
            data += buf
 
        # waiting for file size (may be useful for limits checking)
        while True:
            n = data.find("\n")
            if n >= 0:
                # unpack one long (L) using big endian (>) endianness
                size = struct.unpack(">L",data[:n])[0]
                data = data[n+1:] 
                break
            try:
                buf = cs.recv(1024)
            except socket.error:
                cs.close()
                return
            data += buf
 
        self.body.add(u"Receiving %s (%d bytes)" % (name,size) + self.new_line)            
        # waiting for file contents
        fname = os.path.join(self.dir,name)
        f = open(fname,"wb")
        n = len(data)
        while True:
            f.write(data)
            n += len(data)
            if n % 100 == 0: # a mark at each 100k
                self.body.add(u".")
            try:
                data = cs.recv(1024)
            except socket.error:
                cs.close()
                return
            if not data:
                break
        self.body.add(self.new_line + u"Finished." + self.new_line)
        cs.close()
        f.close()
 
    def server(self,ip,port):
        """ Starts a mono thread server at ip, port
        """
        s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
 
        try:
            s.bind((ip,port))
        except socket.error, (val,msg):
            note(u"Error %d: %s" % (val,msg),"info")
            return
 
        s.listen(1)
 
        while True:
            (cs,addr) = s.accept()
            self.body.add(u"Connect to %s:%d" % (addr[0],addr[1]) + self.new_line)
            self.recv_file(cs,addr)
 
    def sel_access_point(self):
        """ Select and set the default access point.
            Return the access point object if the selection was done or None if not
        """
        aps = socket.access_points()
        if not aps:
            note(u"No access points available","error")
            return None
 
        ap_labels = map(lambda x: x['name'], aps)
        item = popup_menu(ap_labels,u"Access points:")
        if item is None:
            return None
 
        apo = socket.access_point(aps[item]['iapid'])
        socket.set_default_access_point(apo)
 
        return apo
 
    def about(self):
        note(u"RX File by Marcelo Barros (marcelobarrosalmeida@gmail.com)","info")
 
    def run(self):
        self.apo = self.sel_access_point()
        if self.apo:
            self.apo.start()
            self.body.add(u"Starting server." + self.new_line)
            self.body.add(u"IP = %s" % self.apo.ip() + self.new_line)
            self.body.add(u"Port = %d" % self.port + self.new_line)
            self.body.add(u"Repository = %s" % (self.dir) + self.new_line)
            self.server(self.apo.ip(),self.port)
            self.lock.wait()
        app.set_exit()
 
if __name__ == "__main__":
    app = RxFile()
    app.run()
 
 
import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
    s.connect(('nokia.com',2222))
except:
    print "Can´t connect"
 
 
Can´t connect
 
 
import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
    s.connect(('nokia.com',2222))
except socket.error, e:
    print "ERROR: %s" % e
 
 
ERROR: timed out
 
 
import socket
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
    s.connect(('nokiacom',2222))
except socket.gaierror, e:
    print "ADDR ERROR: %s" % e
except socket.error, e:
    print "ERROR: %s" % e
 
 
ADDR ERROR: (11001, 'getaddrinfo failed')
 
 
# -*- coding: utf-8 -*- 
import sys
import time
import thread
 
__all__ = [ "FLOG" ]
 
class FileLog(object):
    def __init__(self,filename):
        self.filename = filename
        self.file = open(self.filename,'at')
        self.lock = thread.allocate_lock()
 
    def add(self,msg):
        # collect caller information from stack call using _getframe
        caller = sys._getframe(1).f_code.co_name
        line = str(sys._getframe(1).f_code.co_firstlineno)
        # create log message
        timestamp = time.strftime("[%Y%m%d %H:%M:%S] ",time.localtime())
        logmsg = timestamp + caller + ":" + line + " - " + msg + " \n"
        # write log message, using a semaphore for controlling the file access
        self.lock.acquire()
        self.file.write(logmsg)
        self.file.flush()
        self.lock.release()
 
FLOG = FileLog("e:\\filelog.txt")
 
 
# 
 
import time
try:
    from btsocket import *
except:
    from socket import *
 
from appuifw import note, popup_menu
 
def sel_access_point():
    aps = access_points()
    if not aps:
        return None
    ap_labels = map(lambda x: x['name'],aps)
    item = popup_menu(ap_labels, u"Access point:")
    if item is None:
        return None
    apo = access_point(aps[item]['iapid'])
    set_default_access_point(apo)
    return apo
 
GROUP = "224.202.20.30"
PORT = 54321
 
apo = sel_access_point()
if apo is not None:
    apo.start()
    sock = socket(AF_INET, SOCK_DGRAM)
    while True:
        n = sock.sendto('hello world',(GROUP,PORT))
        print "Message sent (%d bytes)" % n
        time.sleep(2)
 
 
import time
import sys
import socket
 
GROUP = "224.202.20.30"
PORT = 54321
 
def join_grp(sock,grp,itf):
    # enabling multicasting option for itf
    sock.setsockopt(socket.SOL_IP,
                    socket.IP_MULTICAST_IF,
                    socket.inet_aton(itf))
    # joing to multicast group grp in interface itf
    sock.setsockopt(socket.SOL_IP,
                    socket.IP_ADD_MEMBERSHIP,
                    socket.inet_aton(grp)+socket.inet_aton(itf))
 
def leave_grp(sock,grp):
    # removing
    sock.setsockopt(socket.SOL_IP,
                    socket.IP_DROP_MEMBERSHIP,
                    socket.inet_aton(grp)+socket.inet_aton('0.0.0.0'))
 
itf_addr = '10.0.0.101'
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.bind((itf_addr,PORT))
join_grp(sock,GROUP,itf_addr)
 
for n in range(11):
    (data,addr) = sock.recvfrom(1500)
    print "Received ",data,"from",addr
 
leave_grp(sock,GROUP)
 
 
import time
import sys
import socket
from appuifw import note, popup_menu
 
BCIP = "255.255.255.255"
PORT = 54321
 
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST, True)
while True:
    n = sock.sendto('hello world',(BCIP,PORT))
    print "Message sent (%d bytes)" % n
    time.sleep(2)
 
 
import time
import socket
 
BCIP = "255.255.255.255"
PORT = 54321
 
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET,socket.SO_BROADCAST, True)
 
while True:
    n = sock.sendto('hello world',(BCIP,PORT))
    print "Message sent (%d bytes)" % n
    time.sleep(2)
 
 
import time
import socket
 
PORT = 54321
sock = socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
sock.bind(('0.0.0.0',PORT))
 
while True:
    (data,addr) = sock.recvfrom(1500)
    print "Received ",data,"from",addr
 
 
import socket
import time
 
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect(('127.0.0.1',54321))
 
fsock = sock.makefile()
for i in range(5):
    msg = u"Sending line %d ...\n" % i
    fsock.write(msg)
    print msg
    # call flush to send pending bytes
    fsock.flush()
    time.sleep(1)
sock.close()
 
 
import socket
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',54321))
s.listen(1)
while True:
    sock,addr = s.accept()
    fsock = sock.makefile()
    print "New connection from",addr
    while True:
        line = fsock.readline()
        if not line:
            print "Connection closed"
            break
        print "=> ",line
 
 
import socket
import struct
import random
 
sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect(('127.0.0.1',54321))
 
fsock = sock.makefile()
# creating a random header
version = random.randint(0,5)
size = random.randint(0,10)
header = struct.pack('>LL',version,size)
print "Version:",version
print "Size:",size
fsock.write(header)
data = 'X'*size
print "Data:",data
fsock.write(data)
fsock.flush()
sock.close()
 
 
import socket
import struct
 
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('127.0.0.1',54321))
s.listen(1)
while True:
    sock,addr = s.accept()
    fsock = sock.makefile()
    print "New connection from",addr
    # decoding header
    header = fsock.read(8)
    (version,size) = struct.unpack('>LL',header)
    print "Version:",version
    print "Size:",size
    data = fsock.read(size)
    print "Data:",data
    sock.close()

Basic Network Programming (Python on Symbian)

From Symbian Developer Community

Contents

Introduction

Basic Network Principles

IP Addressing

Subnet masks

Multicast addressing

Socket API introduction

Fortune client/server

Access point selection

Protocols and TCP servers

Exception handler and debugging

Exceptions

Debugging

Advanced Socket API

Multicast

Broadcast

File like sockets

Further reading

Conclusions

Jumpjack said...

Hamishwillee said…

Views

Navigation

Toolbox

In other languages

OUR SITES

DEVELOPER PROGRAMS

Source

Website bugs

Documentation

Forums

CONTACT

Follow us