From 4710c53dcad1ebf3755f3efb9e80ac24bd72a9b2 Mon Sep 17 00:00:00 2001 From: darylm503 Date: Mon, 16 Apr 2012 22:12:42 +0000 Subject: 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 --- .../Python/Python-2.7.2/Demo/sockets/README | 14 + .../Python/Python-2.7.2/Demo/sockets/broadcast.py | 15 + .../Python/Python-2.7.2/Demo/sockets/echosvr.py | 31 ++ .../Python/Python-2.7.2/Demo/sockets/finger.py | 58 ++++ .../Python/Python-2.7.2/Demo/sockets/ftp.py | 146 +++++++++ .../Python/Python-2.7.2/Demo/sockets/gopher.py | 347 +++++++++++++++++++++ .../Python/Python-2.7.2/Demo/sockets/mcast.py | 80 +++++ .../Python/Python-2.7.2/Demo/sockets/radio.py | 14 + .../Python/Python-2.7.2/Demo/sockets/rpython.py | 35 +++ .../Python/Python-2.7.2/Demo/sockets/rpythond.py | 52 +++ .../Python/Python-2.7.2/Demo/sockets/telnet.py | 109 +++++++ .../Python/Python-2.7.2/Demo/sockets/throughput.py | 93 ++++++ .../Python/Python-2.7.2/Demo/sockets/udpecho.py | 63 ++++ .../Python/Python-2.7.2/Demo/sockets/unicast.py | 14 + .../Python/Python-2.7.2/Demo/sockets/unixclient.py | 12 + .../Python/Python-2.7.2/Demo/sockets/unixserver.py | 24 ++ 16 files changed, 1107 insertions(+) create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/README create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/broadcast.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/echosvr.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/finger.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/ftp.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/gopher.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/mcast.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/radio.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpython.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/rpythond.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/telnet.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/throughput.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/udpecho.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unicast.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixclient.py create mode 100644 AppPkg/Applications/Python/Python-2.7.2/Demo/sockets/unixserver.py (limited to 'AppPkg/Applications/Python/Python-2.7.2/Demo/sockets') 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, ('', 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': '', '1': '', '2': '', '3': '', \ + '4': '', '5': '', '6': '', '7': '', \ + '8': '', '9': '', '+': '', 's': ''} + +# 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 '' + 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] 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) -- cgit v1.2.3