| Current File : /home/mmdealscpanel/yummmdeals.com/pysvr.tar |
pysvr.pyo 0000644 00000007456 15037636011 0006476 0 ustar 00 �
A fc @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d Z d � Z d d � Z d � Z d � Z
d � Z d � Z d d
l m Z e � d S( sI A multi-threaded telnet-like server that gives a Python prompt.
This is really a prototype for the same thing in C.
Usage: pysvr.py [port]
For security reasons, it only accepts requests from the current host.
This can still be insecure, but restricts violations from people who
can log in on your machine. Use with caution!
i����Ni� c C s� yD t j t j d d � \ } } t | � d k rC t j d � n Wn t j k
rf } t | � n Xx | D] \ } } qn W| r� y t j | d � } Wq� t k
r� } t | � q� Xn t } t
| � d S( Ni t s Too many arguments.i ( t getoptt syst argvt lent errort usaget stringt atoit
ValueErrort PORTt main_thread( t optst argst msgt ot at port( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyt main s c C s3 t j t _ | r | GHn d Gt Gt j d � d S( Ns
i ( R t stderrt stdoutt __doc__t exit( R ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR % s
c C s� t j t j t j � } | j d | f � | j d � d G| Gd GHxm | j � \ } } | d | j � d k r� | j � d G| d Gd GHqH n t j t
| | f � ~ ~ qH Wd S( NR i s Listening on ports ...i s' Refusing connection from non-local hostt .( t sockett AF_INETt SOCK_STREAMt bindt listent acceptt getsocknamet closet threadt start_new_threadt service_thread( R t sockt connt addr( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR , s
c C sl | \ } } d t t j � � | f G| j d � } | j d d � } t | | � d t t j � � Gd S( Ns" Thread %s has connection from %s.
t rt wi s Thread %s is done.
( t strR t get_identt makefilet run_interpreter( R$ R% t caddrt cportt stdinR ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR" : s
c C s| i } y t t j � Wn d t _ n Xd } x8| j t j � | j � } | d d k rh d } n | rz | rz Pn | d d k r� | d d } n | | } y t | � } Wn5 t k
r� } d } t j t | d d | �q3 n X| s� q3 n d } y t
| | | | � Wq3 t k
rf} | rby t | � } Wn
d } n X| j d | � n Pq3 Xq3 W| j d
� d S( Ns >>> R i s ��i����s
s
t files Exit %s
s
Goodbye.
( R( R t ps1t writet readlinet compile_commandt SyntaxErrort tracebackt print_exceptiont Nonet run_commandt
SystemExit( R. R t globalst sourcet linet codet errt how( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR+ C sH
c B s� e j e j e j f } z� | e _ e _ | e _ y | | UWnl e k
rk } e | e j � d � nD e j � \ } } } | r� | j } n e j | | | � ~ n XWd | \ e _ e _ e _ Xd S( Ni ( R R. R R R9 t exc_infot tb_nextR5 R6 ( R= R. R R: t saveR? t typet valuet tb( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR8 i s ( R3 ( R R t osR R R R R5 R
R R7 R R R" R+ R8 R= R3 ( ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyt <module>
s T & pysvr.py 0000755 00000006545 15037636011 0006320 0 ustar 00 #! /usr/bin/python2.7
"""A multi-threaded telnet-like server that gives a Python prompt.
This is really a prototype for the same thing in C.
Usage: pysvr.py [port]
For security reasons, it only accepts requests from the current host.
This can still be insecure, but restricts violations from people who
can log in on your machine. Use with caution!
"""
import sys, os, string, getopt, thread, socket, traceback
PORT = 4000 # Default port
def main():
try:
opts, args = getopt.getopt(sys.argv[1:], "")
if len(args) > 1:
raise getopt.error, "Too many arguments."
except getopt.error, msg:
usage(msg)
for o, a in opts:
pass
if args:
try:
port = string.atoi(args[0])
except ValueError, msg:
usage(msg)
else:
port = PORT
main_thread(port)
def usage(msg=None):
sys.stdout = sys.stderr
if msg:
print msg
print "\n", __doc__,
sys.exit(2)
def main_thread(port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", port))
sock.listen(5)
print "Listening on port", port, "..."
while 1:
(conn, addr) = sock.accept()
if addr[0] != conn.getsockname()[0]:
conn.close()
print "Refusing connection from non-local host", addr[0], "."
continue
thread.start_new_thread(service_thread, (conn, addr))
del conn, addr
def service_thread(conn, addr):
(caddr, cport) = addr
print "Thread %s has connection from %s.\n" % (str(thread.get_ident()),
caddr),
stdin = conn.makefile("r")
stdout = conn.makefile("w", 0)
run_interpreter(stdin, stdout)
print "Thread %s is done.\n" % str(thread.get_ident()),
def run_interpreter(stdin, stdout):
globals = {}
try:
str(sys.ps1)
except:
sys.ps1 = ">>> "
source = ""
while 1:
stdout.write(sys.ps1)
line = stdin.readline()
if line[:2] == '\377\354':
line = ""
if not line and not source:
break
if line[-2:] == '\r\n':
line = line[:-2] + '\n'
source = source + line
try:
code = compile_command(source)
except SyntaxError, err:
source = ""
traceback.print_exception(SyntaxError, err, None, file=stdout)
continue
if not code:
continue
source = ""
try:
run_command(code, stdin, stdout, globals)
except SystemExit, how:
if how:
try:
how = str(how)
except:
how = ""
stdout.write("Exit %s\n" % how)
break
stdout.write("\nGoodbye.\n")
def run_command(code, stdin, stdout, globals):
save = sys.stdin, sys.stdout, sys.stderr
try:
sys.stdout = sys.stderr = stdout
sys.stdin = stdin
try:
exec code in globals
except SystemExit, how:
raise SystemExit, how, sys.exc_info()[2]
except:
type, value, tb = sys.exc_info()
if tb: tb = tb.tb_next
traceback.print_exception(type, value, tb)
del tb
finally:
sys.stdin, sys.stdout, sys.stderr = save
from code import compile_command
main()
README 0000644 00000000505 15037636011 0005426 0 ustar 00 This is an example of a multi-threaded C application embedding a
Python interpreter.
The particular application is a multi-threaded telnet-like server that
provides you with a Python prompt (instead of a shell prompt).
The file pysvr.py is a prototype in Python.
THIS APPLICATION IS NOT SECURE -- ONLY USE IT FOR TESTING!
pysvr.pyc 0000644 00000007456 15037636011 0006462 0 ustar 00 �
A fc @ s� d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d Z d � Z d d � Z d � Z d � Z
d � Z d � Z d d
l m Z e � d S( sI A multi-threaded telnet-like server that gives a Python prompt.
This is really a prototype for the same thing in C.
Usage: pysvr.py [port]
For security reasons, it only accepts requests from the current host.
This can still be insecure, but restricts violations from people who
can log in on your machine. Use with caution!
i����Ni� c C s� yD t j t j d d � \ } } t | � d k rC t j d � n Wn t j k
rf } t | � n Xx | D] \ } } qn W| r� y t j | d � } Wq� t k
r� } t | � q� Xn t } t
| � d S( Ni t s Too many arguments.i ( t getoptt syst argvt lent errort usaget stringt atoit
ValueErrort PORTt main_thread( t optst argst msgt ot at port( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyt main s c C s3 t j t _ | r | GHn d Gt Gt j d � d S( Ns
i ( R t stderrt stdoutt __doc__t exit( R ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR % s
c C s� t j t j t j � } | j d | f � | j d � d G| Gd GHxm | j � \ } } | d | j � d k r� | j � d G| d Gd GHqH n t j t
| | f � ~ ~ qH Wd S( NR i s Listening on ports ...i s' Refusing connection from non-local hostt .( t sockett AF_INETt SOCK_STREAMt bindt listent acceptt getsocknamet closet threadt start_new_threadt service_thread( R t sockt connt addr( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR , s
c C sl | \ } } d t t j � � | f G| j d � } | j d d � } t | | � d t t j � � Gd S( Ns" Thread %s has connection from %s.
t rt wi s Thread %s is done.
( t strR t get_identt makefilet run_interpreter( R$ R% t caddrt cportt stdinR ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR" : s
c C s| i } y t t j � Wn d t _ n Xd } x8| j t j � | j � } | d d k rh d } n | rz | rz Pn | d d k r� | d d } n | | } y t | � } Wn5 t k
r� } d } t j t | d d | �q3 n X| s� q3 n d } y t
| | | | � Wq3 t k
rf} | rby t | � } Wn
d } n X| j d | � n Pq3 Xq3 W| j d
� d S( Ns >>> R i s ��i����s
s
t files Exit %s
s
Goodbye.
( R( R t ps1t writet readlinet compile_commandt SyntaxErrort tracebackt print_exceptiont Nonet run_commandt
SystemExit( R. R t globalst sourcet linet codet errt how( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR+ C sH
c B s� e j e j e j f } z� | e _ e _ | e _ y | | UWnl e k
rk } e | e j � d � nD e j � \ } } } | r� | j } n e j | | | � ~ n XWd | \ e _ e _ e _ Xd S( Ni ( R R. R R R9 t exc_infot tb_nextR5 R6 ( R= R. R R: t saveR? t typet valuet tb( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyR8 i s ( R3 ( R R t osR R R R R5 R
R R7 R R R" R+ R8 R= R3 ( ( ( s( /usr/lib64/python2.7/Demo/pysvr/pysvr.pyt <module>
s T & pysvr.c 0000644 00000020353 15037636011 0006100 0 ustar 00 /* A multi-threaded telnet-like server that gives a Python prompt.
Usage: pysvr [port]
For security reasons, it only accepts requests from the current host.
This can still be insecure, but restricts violations from people who
can log in on your machine. Use with caution!
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <pthread.h>
#include <getopt.h>
/* XXX Umpfh.
Python.h defines a typedef destructor, which conflicts with pthread.h.
So Python.h must be included after pthread.h. */
#include "Python.h"
extern int Py_VerboseFlag;
#ifndef PORT
#define PORT 4000
#endif
struct workorder {
int conn;
struct sockaddr_in addr;
};
/* Forward */
static void init_python(void);
static void usage(void);
static void oprogname(void);
static void main_thread(int);
static void create_thread(int, struct sockaddr_in *);
static void *service_thread(struct workorder *);
static void run_interpreter(FILE *, FILE *);
static int run_command(char *, PyObject *);
static void ps(void);
static char *progname = "pysvr";
static PyThreadState *gtstate;
main(int argc, char **argv)
{
int port = PORT;
int c;
if (argc > 0 && argv[0] != NULL && argv[0][0] != '\0')
progname = argv[0];
while ((c = getopt(argc, argv, "v")) != EOF) {
switch (c) {
case 'v':
Py_VerboseFlag++;
break;
default:
usage();
}
}
if (optind < argc) {
if (optind+1 < argc) {
oprogname();
fprintf(stderr, "too many arguments\n");
usage();
}
port = atoi(argv[optind]);
if (port <= 0) {
fprintf(stderr, "bad port (%s)\n", argv[optind]);
usage();
}
}
main_thread(port);
fprintf(stderr, "Bye.\n");
exit(0);
}
static char usage_line[] = "usage: %s [port]\n";
static void
usage(void)
{
fprintf(stderr, usage_line, progname);
exit(2);
}
static void
main_thread(int port)
{
int sock, conn, size, i;
struct sockaddr_in addr, clientaddr;
sock = socket(PF_INET, SOCK_STREAM, 0);
if (sock < 0) {
oprogname();
perror("can't create socket");
exit(1);
}
#ifdef SO_REUSEADDR
i = 1;
setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof i);
#endif
memset((char *)&addr, '\0', sizeof addr);
addr.sin_family = AF_INET;
addr.sin_port = htons(port);
addr.sin_addr.s_addr = 0L;
if (bind(sock, (struct sockaddr *)&addr, sizeof addr) < 0) {
oprogname();
perror("can't bind socket to address");
exit(1);
}
if (listen(sock, 5) < 0) {
oprogname();
perror("can't listen on socket");
exit(1);
}
fprintf(stderr, "Listening on port %d...\n", port);
for (i = 0; ; i++) {
size = sizeof clientaddr;
memset((char *) &clientaddr, '\0', size);
conn = accept(sock, (struct sockaddr *) &clientaddr, &size);
if (conn < 0) {
oprogname();
perror("can't accept connection from socket");
exit(1);
}
size = sizeof addr;
memset((char *) &addr, '\0', size);
if (getsockname(conn, (struct sockaddr *)&addr, &size) < 0) {
oprogname();
perror("can't get socket name of connection");
exit(1);
}
if (clientaddr.sin_addr.s_addr != addr.sin_addr.s_addr) {
oprogname();
perror("connection from non-local host refused");
fprintf(stderr, "(addr=%lx, clientaddr=%lx)\n",
ntohl(addr.sin_addr.s_addr),
ntohl(clientaddr.sin_addr.s_addr));
close(conn);
continue;
}
if (i == 4) {
close(conn);
break;
}
create_thread(conn, &clientaddr);
}
close(sock);
if (gtstate) {
PyEval_AcquireThread(gtstate);
gtstate = NULL;
Py_Finalize();
/* And a second time, just because we can. */
Py_Finalize(); /* This should be harmless. */
}
exit(0);
}
static void
create_thread(int conn, struct sockaddr_in *addr)
{
struct workorder *work;
pthread_t tdata;
work = malloc(sizeof(struct workorder));
if (work == NULL) {
oprogname();
fprintf(stderr, "out of memory for thread.\n");
close(conn);
return;
}
work->conn = conn;
work->addr = *addr;
init_python();
if (pthread_create(&tdata, NULL, (void *)service_thread, work) < 0) {
oprogname();
perror("can't create new thread");
close(conn);
return;
}
if (pthread_detach(tdata) < 0) {
oprogname();
perror("can't detach from thread");
}
}
static PyThreadState *the_tstate;
static PyInterpreterState *the_interp;
static PyObject *the_builtins;
static void
init_python(void)
{
if (gtstate)
return;
Py_Initialize(); /* Initialize the interpreter */
PyEval_InitThreads(); /* Create (and acquire) the interpreter lock */
gtstate = PyEval_SaveThread(); /* Release the thread state */
}
static void *
service_thread(struct workorder *work)
{
FILE *input, *output;
fprintf(stderr, "Start thread for connection %d.\n", work->conn);
ps();
input = fdopen(work->conn, "r");
if (input == NULL) {
oprogname();
perror("can't create input stream");
goto done;
}
output = fdopen(work->conn, "w");
if (output == NULL) {
oprogname();
perror("can't create output stream");
fclose(input);
goto done;
}
setvbuf(input, NULL, _IONBF, 0);
setvbuf(output, NULL, _IONBF, 0);
run_interpreter(input, output);
fclose(input);
fclose(output);
done:
fprintf(stderr, "End thread for connection %d.\n", work->conn);
close(work->conn);
free(work);
}
static void
oprogname(void)
{
int save = errno;
fprintf(stderr, "%s: ", progname);
errno = save;
}
static void
run_interpreter(FILE *input, FILE *output)
{
PyThreadState *tstate;
PyObject *new_stdin, *new_stdout;
PyObject *mainmod, *globals;
char buffer[1000];
char *p, *q;
int n, end;
PyEval_AcquireLock();
tstate = Py_NewInterpreter();
if (tstate == NULL) {
fprintf(output, "Sorry -- can't create an interpreter\n");
return;
}
mainmod = PyImport_AddModule("__main__");
globals = PyModule_GetDict(mainmod);
Py_INCREF(globals);
new_stdin = PyFile_FromFile(input, "<socket-in>", "r", NULL);
new_stdout = PyFile_FromFile(output, "<socket-out>", "w", NULL);
PySys_SetObject("stdin", new_stdin);
PySys_SetObject("stdout", new_stdout);
PySys_SetObject("stderr", new_stdout);
for (n = 1; !PyErr_Occurred(); n++) {
Py_BEGIN_ALLOW_THREADS
fprintf(output, "%d> ", n);
p = fgets(buffer, sizeof buffer, input);
Py_END_ALLOW_THREADS
if (p == NULL)
break;
if (p[0] == '\377' && p[1] == '\354')
break;
q = strrchr(p, '\r');
if (q && q[1] == '\n' && q[2] == '\0') {
*q++ = '\n';
*q++ = '\0';
}
while (*p && isspace(*p))
p++;
if (p[0] == '#' || p[0] == '\0')
continue;
end = run_command(buffer, globals);
if (end < 0)
PyErr_Print();
if (end)
break;
}
Py_XDECREF(globals);
Py_XDECREF(new_stdin);
Py_XDECREF(new_stdout);
Py_EndInterpreter(tstate);
PyEval_ReleaseLock();
fprintf(output, "Goodbye!\n");
}
static int
run_command(char *buffer, PyObject *globals)
{
PyObject *m, *d, *v;
fprintf(stderr, "run_command: %s", buffer);
if (strchr(buffer, '\n') == NULL)
fprintf(stderr, "\n");
v = PyRun_String(buffer, Py_single_input, globals, globals);
if (v == NULL) {
if (PyErr_Occurred() == PyExc_SystemExit) {
PyErr_Clear();
return 1;
}
PyErr_Print();
return 0;
}
Py_DECREF(v);
return 0;
}
static void
ps(void)
{
char buffer[100];
PyOS_snprintf(buffer, sizeof(buffer),
"ps -l -p %d </dev/null | sed 1d\n", getpid());
system(buffer);
}
Makefile 0000644 00000002475 15037636011 0006216 0 ustar 00 # Makefile for 'pysvr' application embedding Python.
# Tailored for Python 1.5a3 or later.
# Some details are specific for Solaris or CNRI.
# Also see ## comments for tailoring.
# Which C compiler
CC=gcc
##PURIFY=/usr/local/pure/purify
LINKCC=$(PURIFY) $(CC)
# Optimization preferences
OPT=-g
# Which Python version we're using
VER=2.2
# Expressions using the above definitions
PYVER=python$(VER)
# Use these defs when compiling against installed Python
##INST=/usr/local
##PYC=$(INST)/lib/$(PYVER)/config
##PYINCL=-I$(INST)/include/$(PYVER) -I$(PYC)
##PYLIBS=$(PYC)/lib$(PYVER).a
# Use these defs when compiling against built Python
PLAT=linux
PYINCL=-I../../Include -I../../$(PLAT)
PYLIBS=../../$(PLAT)/lib$(PYVER).a
# Libraries to link with -- very installation dependent
# (See LIBS= in Modules/Makefile in build tree)
RLLIBS=-lreadline -ltermcap
OTHERLIBS=-lnsl -lpthread -ldl -lm -ldb -lutil
# Compilation and link flags -- no need to change normally
CFLAGS=$(OPT)
CPPFLAGS=$(PYINCL)
LIBS=$(PYLIBS) $(RLLIBS) $(OTHERLIBS)
# Default port for the pysvr application
PORT=4000
# Default target
all: pysvr
# Target to build pysvr
pysvr: pysvr.o $(PYOBJS) $(PYLIBS)
$(LINKCC) pysvr.o $(LIBS) -o pysvr
# Target to build and run pysvr
run: pysvr
pysvr $(PORT)
# Target to clean up the directory
clean:
-rm -f pysvr *.o *~ core