diff options
| author | darylm503 <darylm503@6f19259b-4bc3-4df7-8a09-765794883524> | 2012-04-16 22:12:42 +0000 |
|---|---|---|
| committer | darylm503 <darylm503@6f19259b-4bc3-4df7-8a09-765794883524> | 2012-04-16 22:12:42 +0000 |
| commit | 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 (patch) | |
| tree | 2d17d2388a78082e32f6a97120d707328143543b /AppPkg/Applications/Python/Python-2.7.2/Demo/sockets | |
| parent | cbc6b5e54599c7391ece99ad3c5313f4dd4ddda6 (diff) | |
| download | edk2-platforms-4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2.tar.xz | |
AppPkg/Applications/Python: Add Python 2.7.2 sources since the release of Python 2.7.3 made them unavailable from the python.org web site.
These files are a subset of the python-2.7.2.tgz distribution from python.org. Changed files from PyMod-2.7.2 have been copied into the corresponding directories of this tree, replacing the original files in the distribution.
Signed-off-by: daryl.mcdaniel@intel.com
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@13197 6f19259b-4bc3-4df7-8a09-765794883524
Diffstat (limited to 'AppPkg/Applications/Python/Python-2.7.2/Demo/sockets')
16 files changed, 1107 insertions, 0 deletions
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/README b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/README new file mode 100644 index 0000000000..69618fc5bf --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/README @@ -0,0 +1,14 @@ +This directory contains some demonstrations of the socket module:
+
+broadcast.py Broadcast the time to radio.py.
+echosvr.py About the simplest TCP server possible.
+finger.py Client for the 'finger' protocol.
+ftp.py A very simple ftp client.
+gopher.py A simple gopher client.
+mcast.py IPv4/v6 multicast example
+radio.py Receive time broadcasts from broadcast.py.
+telnet.py Client for the 'telnet' protocol.
+throughput.py Client and server to measure TCP throughput.
+unixclient.py Unix socket example, client side
+unixserver.py Unix socket example, server side
+udpecho.py Client and server for the UDP echo protocol.
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/broadcast.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/broadcast.py new file mode 100644 index 0000000000..f0222408c2 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/broadcast.py @@ -0,0 +1,15 @@ +# Send UDP broadcast packets
+
+MYPORT = 50000
+
+import sys, time
+from socket import *
+
+s = socket(AF_INET, SOCK_DGRAM)
+s.bind(('', 0))
+s.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
+
+while 1:
+ data = repr(time.time()) + '\n'
+ s.sendto(data, ('<broadcast>', MYPORT))
+ time.sleep(2)
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/echosvr.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/echosvr.py new file mode 100644 index 0000000000..893a48678b --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/echosvr.py @@ -0,0 +1,31 @@ +#! /usr/bin/env python
+
+# Python implementation of an 'echo' tcp server: echo all data it receives.
+#
+# This is the simplest possible server, servicing a single request only.
+
+import sys
+from socket import *
+
+# The standard echo port isn't very useful, it requires root permissions!
+# ECHO_PORT = 7
+ECHO_PORT = 50000 + 7
+BUFSIZE = 1024
+
+def main():
+ if len(sys.argv) > 1:
+ port = int(eval(sys.argv[1]))
+ else:
+ port = ECHO_PORT
+ s = socket(AF_INET, SOCK_STREAM)
+ s.bind(('', port))
+ s.listen(1)
+ conn, (remotehost, remoteport) = s.accept()
+ print 'connected by', remotehost, remoteport
+ while 1:
+ data = conn.recv(BUFSIZE)
+ if not data:
+ break
+ conn.send(data)
+
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/finger.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/finger.py new file mode 100644 index 0000000000..9cd854ccc4 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/finger.py @@ -0,0 +1,58 @@ +#! /usr/bin/env python
+
+# Python interface to the Internet finger daemon.
+#
+# Usage: finger [options] [user][@host] ...
+#
+# If no host is given, the finger daemon on the local host is contacted.
+# Options are passed uninterpreted to the finger daemon!
+
+
+import sys, string
+from socket import *
+
+
+# Hardcode the number of the finger port here.
+# It's not likely to change soon...
+#
+FINGER_PORT = 79
+
+
+# Function to do one remote finger invocation.
+# Output goes directly to stdout (although this can be changed).
+#
+def finger(host, args):
+ s = socket(AF_INET, SOCK_STREAM)
+ s.connect((host, FINGER_PORT))
+ s.send(args + '\n')
+ while 1:
+ buf = s.recv(1024)
+ if not buf: break
+ sys.stdout.write(buf)
+ sys.stdout.flush()
+
+
+# Main function: argument parsing.
+#
+def main():
+ options = ''
+ i = 1
+ while i < len(sys.argv) and sys.argv[i][:1] == '-':
+ options = options + sys.argv[i] + ' '
+ i = i+1
+ args = sys.argv[i:]
+ if not args:
+ args = ['']
+ for arg in args:
+ if '@' in arg:
+ at = string.index(arg, '@')
+ host = arg[at+1:]
+ arg = arg[:at]
+ else:
+ host = ''
+ finger(host, options + arg)
+
+
+# Call the main function.
+#
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/ftp.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/ftp.py new file mode 100644 index 0000000000..3acdabfe37 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/ftp.py @@ -0,0 +1,146 @@ +# A simple FTP client.
+#
+# The information to write this program was gathered from RFC 959,
+# but this is not a complete implementation! Yet it shows how a simple
+# FTP client can be built, and you are welcome to extend it to suit
+# it to your needs...
+#
+# How it works (assuming you've read the RFC):
+#
+# User commands are passed uninterpreted to the server. However, the
+# user never needs to send a PORT command. Rather, the client opens a
+# port right away and sends the appropriate PORT command to the server.
+# When a response code 150 is received, this port is used to receive
+# the data (which is written to stdout in this version), and when the
+# data is exhausted, a new port is opened and a corresponding PORT
+# command sent. In order to avoid errors when reusing ports quickly
+# (and because there is no s.getsockname() method in Python yet) we
+# cycle through a number of ports in the 50000 range.
+
+
+import sys, posix, string
+from socket import *
+
+
+BUFSIZE = 1024
+
+# Default port numbers used by the FTP protocol.
+#
+FTP_PORT = 21
+FTP_DATA_PORT = FTP_PORT - 1
+
+# Change the data port to something not needing root permissions.
+#
+FTP_DATA_PORT = FTP_DATA_PORT + 50000
+
+
+# Main program (called at the end of this file).
+#
+def main():
+ hostname = sys.argv[1]
+ control(hostname)
+
+
+# Control process (user interface and user protocol interpreter).
+#
+def control(hostname):
+ #
+ # Create control connection
+ #
+ s = socket(AF_INET, SOCK_STREAM)
+ s.connect((hostname, FTP_PORT))
+ f = s.makefile('r') # Reading the replies is easier from a file...
+ #
+ # Control loop
+ #
+ r = None
+ while 1:
+ code = getreply(f)
+ if code in ('221', 'EOF'): break
+ if code == '150':
+ getdata(r)
+ code = getreply(f)
+ r = None
+ if not r:
+ r = newdataport(s, f)
+ cmd = getcommand()
+ if not cmd: break
+ s.send(cmd + '\r\n')
+
+
+# Create a new data port and send a PORT command to the server for it.
+# (Cycle through a number of ports to avoid problems with reusing
+# a port within a short time.)
+#
+nextport = 0
+#
+def newdataport(s, f):
+ global nextport
+ port = nextport + FTP_DATA_PORT
+ nextport = (nextport+1) % 16
+ r = socket(AF_INET, SOCK_STREAM)
+ r.bind((gethostbyname(gethostname()), port))
+ r.listen(1)
+ sendportcmd(s, f, port)
+ return r
+
+
+# Send an appropriate port command.
+#
+def sendportcmd(s, f, port):
+ hostname = gethostname()
+ hostaddr = gethostbyname(hostname)
+ hbytes = string.splitfields(hostaddr, '.')
+ pbytes = [repr(port//256), repr(port%256)]
+ bytes = hbytes + pbytes
+ cmd = 'PORT ' + string.joinfields(bytes, ',')
+ s.send(cmd + '\r\n')
+ code = getreply(f)
+
+
+# Process an ftp reply and return the 3-digit reply code (as a string).
+# The reply should be a line of text starting with a 3-digit number.
+# If the 4th char is '-', it is a multi-line reply and is
+# terminate by a line starting with the same 3-digit number.
+# Any text while receiving the reply is echoed to the file.
+#
+def getreply(f):
+ line = f.readline()
+ if not line: return 'EOF'
+ print line,
+ code = line[:3]
+ if line[3:4] == '-':
+ while 1:
+ line = f.readline()
+ if not line: break # Really an error
+ print line,
+ if line[:3] == code and line[3:4] != '-': break
+ return code
+
+
+# Get the data from the data connection.
+#
+def getdata(r):
+ print '(accepting data connection)'
+ conn, host = r.accept()
+ print '(data connection accepted)'
+ while 1:
+ data = conn.recv(BUFSIZE)
+ if not data: break
+ sys.stdout.write(data)
+ print '(end of data connection)'
+
+# Get a command from the user.
+#
+def getcommand():
+ try:
+ while 1:
+ line = raw_input('ftp.py> ')
+ if line: return line
+ except EOFError:
+ return ''
+
+
+# Call the main program.
+#
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/gopher.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/gopher.py new file mode 100644 index 0000000000..e47eca5f24 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/gopher.py @@ -0,0 +1,347 @@ +#! /usr/bin/env python
+
+# A simple gopher client.
+#
+# Usage: gopher [ [selector] host [port] ]
+
+import string
+import sys
+import os
+import socket
+
+# Default selector, host and port
+DEF_SELECTOR = ''
+DEF_HOST = 'gopher.micro.umn.edu'
+DEF_PORT = 70
+
+# Recognized file types
+T_TEXTFILE = '0'
+T_MENU = '1'
+T_CSO = '2'
+T_ERROR = '3'
+T_BINHEX = '4'
+T_DOS = '5'
+T_UUENCODE = '6'
+T_SEARCH = '7'
+T_TELNET = '8'
+T_BINARY = '9'
+T_REDUNDANT = '+'
+T_SOUND = 's'
+
+# Dictionary mapping types to strings
+typename = {'0': '<TEXT>', '1': '<DIR>', '2': '<CSO>', '3': '<ERROR>', \
+ '4': '<BINHEX>', '5': '<DOS>', '6': '<UUENCODE>', '7': '<SEARCH>', \
+ '8': '<TELNET>', '9': '<BINARY>', '+': '<REDUNDANT>', 's': '<SOUND>'}
+
+# Oft-used characters and strings
+CRLF = '\r\n'
+TAB = '\t'
+
+# Open a TCP connection to a given host and port
+def open_socket(host, port):
+ if not port:
+ port = DEF_PORT
+ elif type(port) == type(''):
+ port = string.atoi(port)
+ s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+ s.connect((host, port))
+ return s
+
+# Send a selector to a given host and port, return a file with the reply
+def send_request(selector, host, port):
+ s = open_socket(host, port)
+ s.send(selector + CRLF)
+ s.shutdown(1)
+ return s.makefile('r')
+
+# Get a menu in the form of a list of entries
+def get_menu(selector, host, port):
+ f = send_request(selector, host, port)
+ list = []
+ while 1:
+ line = f.readline()
+ if not line:
+ print '(Unexpected EOF from server)'
+ break
+ if line[-2:] == CRLF:
+ line = line[:-2]
+ elif line[-1:] in CRLF:
+ line = line[:-1]
+ if line == '.':
+ break
+ if not line:
+ print '(Empty line from server)'
+ continue
+ typechar = line[0]
+ parts = string.splitfields(line[1:], TAB)
+ if len(parts) < 4:
+ print '(Bad line from server: %r)' % (line,)
+ continue
+ if len(parts) > 4:
+ print '(Extra info from server: %r)' % (parts[4:],)
+ parts.insert(0, typechar)
+ list.append(parts)
+ f.close()
+ return list
+
+# Get a text file as a list of lines, with trailing CRLF stripped
+def get_textfile(selector, host, port):
+ list = []
+ get_alt_textfile(selector, host, port, list.append)
+ return list
+
+# Get a text file and pass each line to a function, with trailing CRLF stripped
+def get_alt_textfile(selector, host, port, func):
+ f = send_request(selector, host, port)
+ while 1:
+ line = f.readline()
+ if not line:
+ print '(Unexpected EOF from server)'
+ break
+ if line[-2:] == CRLF:
+ line = line[:-2]
+ elif line[-1:] in CRLF:
+ line = line[:-1]
+ if line == '.':
+ break
+ if line[:2] == '..':
+ line = line[1:]
+ func(line)
+ f.close()
+
+# Get a binary file as one solid data block
+def get_binary(selector, host, port):
+ f = send_request(selector, host, port)
+ data = f.read()
+ f.close()
+ return data
+
+# Get a binary file and pass each block to a function
+def get_alt_binary(selector, host, port, func, blocksize):
+ f = send_request(selector, host, port)
+ while 1:
+ data = f.read(blocksize)
+ if not data:
+ break
+ func(data)
+
+# A *very* simple interactive browser
+
+# Browser main command, has default arguments
+def browser(*args):
+ selector = DEF_SELECTOR
+ host = DEF_HOST
+ port = DEF_PORT
+ n = len(args)
+ if n > 0 and args[0]:
+ selector = args[0]
+ if n > 1 and args[1]:
+ host = args[1]
+ if n > 2 and args[2]:
+ port = args[2]
+ if n > 3:
+ raise RuntimeError, 'too many args'
+ try:
+ browse_menu(selector, host, port)
+ except socket.error, msg:
+ print 'Socket error:', msg
+ sys.exit(1)
+ except KeyboardInterrupt:
+ print '\n[Goodbye]'
+
+# Browse a menu
+def browse_menu(selector, host, port):
+ list = get_menu(selector, host, port)
+ while 1:
+ print '----- MENU -----'
+ print 'Selector:', repr(selector)
+ print 'Host:', host, ' Port:', port
+ print
+ for i in range(len(list)):
+ item = list[i]
+ typechar, description = item[0], item[1]
+ print string.rjust(repr(i+1), 3) + ':', description,
+ if typename.has_key(typechar):
+ print typename[typechar]
+ else:
+ print '<TYPE=' + repr(typechar) + '>'
+ print
+ while 1:
+ try:
+ str = raw_input('Choice [CR == up a level]: ')
+ except EOFError:
+ print
+ return
+ if not str:
+ return
+ try:
+ choice = string.atoi(str)
+ except string.atoi_error:
+ print 'Choice must be a number; try again:'
+ continue
+ if not 0 < choice <= len(list):
+ print 'Choice out of range; try again:'
+ continue
+ break
+ item = list[choice-1]
+ typechar = item[0]
+ [i_selector, i_host, i_port] = item[2:5]
+ if typebrowser.has_key(typechar):
+ browserfunc = typebrowser[typechar]
+ try:
+ browserfunc(i_selector, i_host, i_port)
+ except (IOError, socket.error):
+ print '***', sys.exc_type, ':', sys.exc_value
+ else:
+ print 'Unsupported object type'
+
+# Browse a text file
+def browse_textfile(selector, host, port):
+ x = None
+ try:
+ p = os.popen('${PAGER-more}', 'w')
+ x = SaveLines(p)
+ get_alt_textfile(selector, host, port, x.writeln)
+ except IOError, msg:
+ print 'IOError:', msg
+ if x:
+ x.close()
+ f = open_savefile()
+ if not f:
+ return
+ x = SaveLines(f)
+ try:
+ get_alt_textfile(selector, host, port, x.writeln)
+ print 'Done.'
+ except IOError, msg:
+ print 'IOError:', msg
+ x.close()
+
+# Browse a search index
+def browse_search(selector, host, port):
+ while 1:
+ print '----- SEARCH -----'
+ print 'Selector:', repr(selector)
+ print 'Host:', host, ' Port:', port
+ print
+ try:
+ query = raw_input('Query [CR == up a level]: ')
+ except EOFError:
+ print
+ break
+ query = string.strip(query)
+ if not query:
+ break
+ if '\t' in query:
+ print 'Sorry, queries cannot contain tabs'
+ continue
+ browse_menu(selector + TAB + query, host, port)
+
+# "Browse" telnet-based information, i.e. open a telnet session
+def browse_telnet(selector, host, port):
+ if selector:
+ print 'Log in as', repr(selector)
+ if type(port) <> type(''):
+ port = repr(port)
+ sts = os.system('set -x; exec telnet ' + host + ' ' + port)
+ if sts:
+ print 'Exit status:', sts
+
+# "Browse" a binary file, i.e. save it to a file
+def browse_binary(selector, host, port):
+ f = open_savefile()
+ if not f:
+ return
+ x = SaveWithProgress(f)
+ get_alt_binary(selector, host, port, x.write, 8*1024)
+ x.close()
+
+# "Browse" a sound file, i.e. play it or save it
+def browse_sound(selector, host, port):
+ browse_binary(selector, host, port)
+
+# Dictionary mapping types to browser functions
+typebrowser = {'0': browse_textfile, '1': browse_menu, \
+ '4': browse_binary, '5': browse_binary, '6': browse_textfile, \
+ '7': browse_search, \
+ '8': browse_telnet, '9': browse_binary, 's': browse_sound}
+
+# Class used to save lines, appending a newline to each line
+class SaveLines:
+ def __init__(self, f):
+ self.f = f
+ def writeln(self, line):
+ self.f.write(line + '\n')
+ def close(self):
+ sts = self.f.close()
+ if sts:
+ print 'Exit status:', sts
+
+# Class used to save data while showing progress
+class SaveWithProgress:
+ def __init__(self, f):
+ self.f = f
+ def write(self, data):
+ sys.stdout.write('#')
+ sys.stdout.flush()
+ self.f.write(data)
+ def close(self):
+ print
+ sts = self.f.close()
+ if sts:
+ print 'Exit status:', sts
+
+# Ask for and open a save file, or return None if not to save
+def open_savefile():
+ try:
+ savefile = raw_input( \
+ 'Save as file [CR == don\'t save; |pipeline or ~user/... OK]: ')
+ except EOFError:
+ print
+ return None
+ savefile = string.strip(savefile)
+ if not savefile:
+ return None
+ if savefile[0] == '|':
+ cmd = string.strip(savefile[1:])
+ try:
+ p = os.popen(cmd, 'w')
+ except IOError, msg:
+ print repr(cmd), ':', msg
+ return None
+ print 'Piping through', repr(cmd), '...'
+ return p
+ if savefile[0] == '~':
+ savefile = os.path.expanduser(savefile)
+ try:
+ f = open(savefile, 'w')
+ except IOError, msg:
+ print repr(savefile), ':', msg
+ return None
+ print 'Saving to', repr(savefile), '...'
+ return f
+
+# Test program
+def test():
+ if sys.argv[4:]:
+ print 'usage: gopher [ [selector] host [port] ]'
+ sys.exit(2)
+ elif sys.argv[3:]:
+ browser(sys.argv[1], sys.argv[2], sys.argv[3])
+ elif sys.argv[2:]:
+ try:
+ port = string.atoi(sys.argv[2])
+ selector = ''
+ host = sys.argv[1]
+ except string.atoi_error:
+ selector = sys.argv[1]
+ host = sys.argv[2]
+ port = ''
+ browser(selector, host, port)
+ elif sys.argv[1:]:
+ browser('', sys.argv[1])
+ else:
+ browser()
+
+# Call the test program as a main program
+test()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/mcast.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/mcast.py new file mode 100644 index 0000000000..55d405eec0 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/mcast.py @@ -0,0 +1,80 @@ +#!/usr/bin/env python
+#
+# Send/receive UDP multicast packets.
+# Requires that your OS kernel supports IP multicast.
+#
+# Usage:
+# mcast -s (sender, IPv4)
+# mcast -s -6 (sender, IPv6)
+# mcast (receivers, IPv4)
+# mcast -6 (receivers, IPv6)
+
+MYPORT = 8123
+MYGROUP_4 = '225.0.0.250'
+MYGROUP_6 = 'ff15:7079:7468:6f6e:6465:6d6f:6d63:6173'
+MYTTL = 1 # Increase to reach other networks
+
+import time
+import struct
+import socket
+import sys
+
+def main():
+ group = MYGROUP_6 if "-6" in sys.argv[1:] else MYGROUP_4
+
+ if "-s" in sys.argv[1:]:
+ sender(group)
+ else:
+ receiver(group)
+
+
+def sender(group):
+ addrinfo = socket.getaddrinfo(group, None)[0]
+
+ s = socket.socket(addrinfo[0], socket.SOCK_DGRAM)
+
+ # Set Time-to-live (optional)
+ ttl_bin = struct.pack('@i', MYTTL)
+ if addrinfo[0] == socket.AF_INET: # IPv4
+ s.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_TTL, ttl_bin)
+ else:
+ s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_MULTICAST_HOPS, ttl_bin)
+
+ while True:
+ data = repr(time.time())
+ s.sendto(data + '\0', (addrinfo[4][0], MYPORT))
+ time.sleep(1)
+
+
+def receiver(group):
+ # Look up multicast group address in name server and find out IP version
+ addrinfo = socket.getaddrinfo(group, None)[0]
+
+ # Create a socket
+ s = socket.socket(addrinfo[0], socket.SOCK_DGRAM)
+
+ # Allow multiple copies of this program on one machine
+ # (not strictly needed)
+ s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+
+ # Bind it to the port
+ s.bind(('', MYPORT))
+
+ group_bin = socket.inet_pton(addrinfo[0], addrinfo[4][0])
+ # Join group
+ if addrinfo[0] == socket.AF_INET: # IPv4
+ mreq = group_bin + struct.pack('=I', socket.INADDR_ANY)
+ s.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
+ else:
+ mreq = group_bin + struct.pack('@I', 0)
+ s.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_JOIN_GROUP, mreq)
+
+ # Loop, printing any data we receive
+ while True:
+ data, sender = s.recvfrom(1500)
+ while data[-1:] == '\0': data = data[:-1] # Strip trailing \0's
+ print (str(sender) + ' ' + repr(data))
+
+
+if __name__ == '__main__':
+ main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/radio.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/radio.py new file mode 100644 index 0000000000..084ef88ca9 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/radio.py @@ -0,0 +1,14 @@ +# Receive UDP packets transmitted by a broadcasting service
+
+MYPORT = 50000
+
+import sys
+from socket import *
+
+s = socket(AF_INET, SOCK_DGRAM)
+s.bind(('', MYPORT))
+
+while 1:
+ data, wherefrom = s.recvfrom(1500, 0)
+ sys.stderr.write(repr(wherefrom) + '\n')
+ sys.stdout.write(data)
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpython.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpython.py new file mode 100644 index 0000000000..a28de1d0c5 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpython.py @@ -0,0 +1,35 @@ +#! /usr/bin/env python
+
+# Remote python client.
+# Execute Python commands remotely and send output back.
+
+import sys
+import string
+from socket import *
+
+PORT = 4127
+BUFSIZE = 1024
+
+def main():
+ if len(sys.argv) < 3:
+ print "usage: rpython host command"
+ sys.exit(2)
+ host = sys.argv[1]
+ port = PORT
+ i = string.find(host, ':')
+ if i >= 0:
+ port = string.atoi(port[i+1:])
+ host = host[:i]
+ command = string.join(sys.argv[2:])
+ s = socket(AF_INET, SOCK_STREAM)
+ s.connect((host, port))
+ s.send(command)
+ s.shutdown(1)
+ reply = ''
+ while 1:
+ data = s.recv(BUFSIZE)
+ if not data: break
+ reply = reply + data
+ print reply,
+
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpythond.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpythond.py new file mode 100644 index 0000000000..50653fbaf5 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpythond.py @@ -0,0 +1,52 @@ +#! /usr/bin/env python
+
+# Remote python server.
+# Execute Python commands remotely and send output back.
+# WARNING: This version has a gaping security hole -- it accepts requests
+# from any host on the Internet!
+
+import sys
+from socket import *
+import StringIO
+import traceback
+
+PORT = 4127
+BUFSIZE = 1024
+
+def main():
+ if len(sys.argv) > 1:
+ port = int(eval(sys.argv[1]))
+ else:
+ port = PORT
+ s = socket(AF_INET, SOCK_STREAM)
+ s.bind(('', port))
+ s.listen(1)
+ while 1:
+ conn, (remotehost, remoteport) = s.accept()
+ print 'connected by', remotehost, remoteport
+ request = ''
+ while 1:
+ data = conn.recv(BUFSIZE)
+ if not data:
+ break
+ request = request + data
+ reply = execute(request)
+ conn.send(reply)
+ conn.close()
+
+def execute(request):
+ stdout = sys.stdout
+ stderr = sys.stderr
+ sys.stdout = sys.stderr = fakefile = StringIO.StringIO()
+ try:
+ try:
+ exec request in {}, {}
+ except:
+ print
+ traceback.print_exc(100)
+ finally:
+ sys.stderr = stderr
+ sys.stdout = stdout
+ return fakefile.getvalue()
+
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/telnet.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/telnet.py new file mode 100644 index 0000000000..1702392203 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/telnet.py @@ -0,0 +1,109 @@ +#! /usr/bin/env python
+
+# Minimal interface to the Internet telnet protocol.
+#
+# It refuses all telnet options and does not recognize any of the other
+# telnet commands, but can still be used to connect in line-by-line mode.
+# It's also useful to play with a number of other services,
+# like time, finger, smtp and even ftp.
+#
+# Usage: telnet host [port]
+#
+# The port may be a service name or a decimal port number;
+# it defaults to 'telnet'.
+
+
+import sys, posix, time
+from socket import *
+
+BUFSIZE = 1024
+
+# Telnet protocol characters
+
+IAC = chr(255) # Interpret as command
+DONT = chr(254)
+DO = chr(253)
+WONT = chr(252)
+WILL = chr(251)
+
+def main():
+ host = sys.argv[1]
+ try:
+ hostaddr = gethostbyname(host)
+ except error:
+ sys.stderr.write(sys.argv[1] + ': bad host name\n')
+ sys.exit(2)
+ #
+ if len(sys.argv) > 2:
+ servname = sys.argv[2]
+ else:
+ servname = 'telnet'
+ #
+ if '0' <= servname[:1] <= '9':
+ port = eval(servname)
+ else:
+ try:
+ port = getservbyname(servname, 'tcp')
+ except error:
+ sys.stderr.write(servname + ': bad tcp service name\n')
+ sys.exit(2)
+ #
+ s = socket(AF_INET, SOCK_STREAM)
+ #
+ try:
+ s.connect((host, port))
+ except error, msg:
+ sys.stderr.write('connect failed: ' + repr(msg) + '\n')
+ sys.exit(1)
+ #
+ pid = posix.fork()
+ #
+ if pid == 0:
+ # child -- read stdin, write socket
+ while 1:
+ line = sys.stdin.readline()
+ s.send(line)
+ else:
+ # parent -- read socket, write stdout
+ iac = 0 # Interpret next char as command
+ opt = '' # Interpret next char as option
+ while 1:
+ data = s.recv(BUFSIZE)
+ if not data:
+ # EOF; kill child and exit
+ sys.stderr.write( '(Closed by remote host)\n')
+ posix.kill(pid, 9)
+ sys.exit(1)
+ cleandata = ''
+ for c in data:
+ if opt:
+ print ord(c)
+ s.send(opt + c)
+ opt = ''
+ elif iac:
+ iac = 0
+ if c == IAC:
+ cleandata = cleandata + c
+ elif c in (DO, DONT):
+ if c == DO: print '(DO)',
+ else: print '(DONT)',
+ opt = IAC + WONT
+ elif c in (WILL, WONT):
+ if c == WILL: print '(WILL)',
+ else: print '(WONT)',
+ opt = IAC + DONT
+ else:
+ print '(command)', ord(c)
+ elif c == IAC:
+ iac = 1
+ print '(IAC)',
+ else:
+ cleandata = cleandata + c
+ sys.stdout.write(cleandata)
+ sys.stdout.flush()
+
+
+try:
+ main()
+except KeyboardInterrupt:
+ pass
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/throughput.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/throughput.py new file mode 100644 index 0000000000..6ac76af397 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/throughput.py @@ -0,0 +1,93 @@ +#! /usr/bin/env python
+
+# Test network throughput.
+#
+# Usage:
+# 1) on host_A: throughput -s [port] # start a server
+# 2) on host_B: throughput -c count host_A [port] # start a client
+#
+# The server will service multiple clients until it is killed.
+#
+# The client performs one transfer of count*BUFSIZE bytes and
+# measures the time it takes (roundtrip!).
+
+
+import sys, time
+from socket import *
+
+MY_PORT = 50000 + 42
+
+BUFSIZE = 1024
+
+
+def main():
+ if len(sys.argv) < 2:
+ usage()
+ if sys.argv[1] == '-s':
+ server()
+ elif sys.argv[1] == '-c':
+ client()
+ else:
+ usage()
+
+
+def usage():
+ sys.stdout = sys.stderr
+ print 'Usage: (on host_A) throughput -s [port]'
+ print 'and then: (on host_B) throughput -c count host_A [port]'
+ sys.exit(2)
+
+
+def server():
+ if len(sys.argv) > 2:
+ port = eval(sys.argv[2])
+ else:
+ port = MY_PORT
+ s = socket(AF_INET, SOCK_STREAM)
+ s.bind(('', port))
+ s.listen(1)
+ print 'Server ready...'
+ while 1:
+ conn, (host, remoteport) = s.accept()
+ while 1:
+ data = conn.recv(BUFSIZE)
+ if not data:
+ break
+ del data
+ conn.send('OK\n')
+ conn.close()
+ print 'Done with', host, 'port', remoteport
+
+
+def client():
+ if len(sys.argv) < 4:
+ usage()
+ count = int(eval(sys.argv[2]))
+ host = sys.argv[3]
+ if len(sys.argv) > 4:
+ port = eval(sys.argv[4])
+ else:
+ port = MY_PORT
+ testdata = 'x' * (BUFSIZE-1) + '\n'
+ t1 = time.time()
+ s = socket(AF_INET, SOCK_STREAM)
+ t2 = time.time()
+ s.connect((host, port))
+ t3 = time.time()
+ i = 0
+ while i < count:
+ i = i+1
+ s.send(testdata)
+ s.shutdown(1) # Send EOF
+ t4 = time.time()
+ data = s.recv(BUFSIZE)
+ t5 = time.time()
+ print data
+ print 'Raw timers:', t1, t2, t3, t4, t5
+ print 'Intervals:', t2-t1, t3-t2, t4-t3, t5-t4
+ print 'Total:', t5-t1
+ print 'Throughput:', round((BUFSIZE*count*0.001) / (t5-t1), 3),
+ print 'K/sec.'
+
+
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/udpecho.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/udpecho.py new file mode 100644 index 0000000000..ea7d396a26 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/udpecho.py @@ -0,0 +1,63 @@ +#! /usr/bin/env python
+
+# Client and server for udp (datagram) echo.
+#
+# Usage: udpecho -s [port] (to start a server)
+# or: udpecho -c host [port] <file (client)
+
+import sys
+from socket import *
+
+ECHO_PORT = 50000 + 7
+BUFSIZE = 1024
+
+def main():
+ if len(sys.argv) < 2:
+ usage()
+ if sys.argv[1] == '-s':
+ server()
+ elif sys.argv[1] == '-c':
+ client()
+ else:
+ usage()
+
+def usage():
+ sys.stdout = sys.stderr
+ print 'Usage: udpecho -s [port] (server)'
+ print 'or: udpecho -c host [port] <file (client)'
+ sys.exit(2)
+
+def server():
+ if len(sys.argv) > 2:
+ port = eval(sys.argv[2])
+ else:
+ port = ECHO_PORT
+ s = socket(AF_INET, SOCK_DGRAM)
+ s.bind(('', port))
+ print 'udp echo server ready'
+ while 1:
+ data, addr = s.recvfrom(BUFSIZE)
+ print 'server received %r from %r' % (data, addr)
+ s.sendto(data, addr)
+
+def client():
+ if len(sys.argv) < 3:
+ usage()
+ host = sys.argv[2]
+ if len(sys.argv) > 3:
+ port = eval(sys.argv[3])
+ else:
+ port = ECHO_PORT
+ addr = host, port
+ s = socket(AF_INET, SOCK_DGRAM)
+ s.bind(('', 0))
+ print 'udp echo client ready, reading stdin'
+ while 1:
+ line = sys.stdin.readline()
+ if not line:
+ break
+ s.sendto(line, addr)
+ data, fromaddr = s.recvfrom(BUFSIZE)
+ print 'client received %r from %r' % (data, fromaddr)
+
+main()
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unicast.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unicast.py new file mode 100644 index 0000000000..9d36f45f97 --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unicast.py @@ -0,0 +1,14 @@ +# Send UDP broadcast packets
+
+MYPORT = 50000
+
+import sys, time
+from socket import *
+
+s = socket(AF_INET, SOCK_DGRAM)
+s.bind(('', 0))
+
+while 1:
+ data = repr(time.time()) + '\n'
+ s.sendto(data, ('', MYPORT))
+ time.sleep(2)
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixclient.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixclient.py new file mode 100644 index 0000000000..369e225f4e --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixclient.py @@ -0,0 +1,12 @@ +# Echo client demo using Unix sockets
+# Piet van Oostrum
+
+from socket import *
+
+FILE = 'unix-socket'
+s = socket(AF_UNIX, SOCK_STREAM)
+s.connect(FILE)
+s.send('Hello, world')
+data = s.recv(1024)
+s.close()
+print 'Received', repr(data)
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixserver.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixserver.py new file mode 100644 index 0000000000..a597b3ba8b --- /dev/null +++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixserver.py @@ -0,0 +1,24 @@ +# Echo server demo using Unix sockets (handles one connection only)
+# Piet van Oostrum
+
+import os
+from socket import *
+
+FILE = 'unix-socket'
+s = socket(AF_UNIX, SOCK_STREAM)
+s.bind(FILE)
+
+print 'Sock name is: ['+s.getsockname()+']'
+
+# Wait for a connection
+s.listen(1)
+conn, addr = s.accept()
+
+while True:
+ data = conn.recv(1024)
+ if not data:
+ break
+ conn.send(data)
+
+conn.close()
+os.unlink(FILE)
|