1 /* A multi-threaded telnet-like server that gives a Python prompt.

     2 

     3 Usage: pysvr [port]

     4 

     5 For security reasons, it only accepts requests from the current host.

     6 This can still be insecure, but restricts violations from people who

     7 can log in on your machine.  Use with caution!

     8 

     9 */

    10 

    11 #include <stdio.h>

    12 #include <stdlib.h>

    13 #include <string.h>

    14 #include <ctype.h>

    15 #include <errno.h>

    16 

    17 #include <sys/types.h>

    18 #include <sys/socket.h>

    19 #include <netinet/in.h>

    20 

    21 #include <pthread.h>

    22 #include <getopt.h>

    23 

    24 /* XXX Umpfh.

    25    Python.h defines a typedef destructor, which conflicts with pthread.h.

    26    So Python.h must be included after pthread.h. */

    27 

    28 #include "Python.h"

    29 

    30 extern int Py_VerboseFlag;

    31 

    32 #ifndef PORT

    33 #define PORT 4000

    34 #endif

    35 

    36 struct workorder {

    37 	int conn;

    38 	struct sockaddr_in addr;

    39 };

    40 

    41 /* Forward */

    42 static void init_python(void);

    43 static void usage(void);

    44 static void oprogname(void);

    45 static void main_thread(int);

    46 static void create_thread(int, struct sockaddr_in *);

    47 static void *service_thread(struct workorder *);

    48 static void run_interpreter(FILE *, FILE *);

    49 static int run_command(char *, PyObject *);

    50 static void ps(void);

    51 

    52 static char *progname = "pysvr";

    53 

    54 static PyThreadState *gtstate;

    55 

    56 main(int argc, char **argv)

    57 {

    58 	int port = PORT;

    59 	int c;

    60 

    61 	if (argc > 0 && argv[0] != NULL && argv[0][0] != '\0')

    62 		progname = argv[0];

    63 

    64 	while ((c = getopt(argc, argv, "v")) != EOF) {

    65 		switch (c) {

    66 		case 'v':

    67 			Py_VerboseFlag++;

    68 			break;

    69 		default:

    70 			usage();

    71 		}

    72 	}

    73 

    74 	if (optind < argc) {

    75 		if (optind+1 < argc) {

    76 			oprogname();

    77 			fprintf(stderr, "too many arguments\n");

    78 			usage();

    79 		}

    80 		port = atoi(argv[optind]);

    81 		if (port <= 0) {

    82 			fprintf(stderr, "bad port (%s)\n", argv[optind]);

    83 			usage();

    84 		}

    85 	}

    86 

    87 	main_thread(port);

    88 

    89 	fprintf(stderr, "Bye.\n");

    90 

    91 	exit(0);

    92 }

    93 

    94 static char usage_line[] = "usage: %s [port]\n";

    95 

    96 static void

    97 usage(void)

    98 {

    99 	fprintf(stderr, usage_line, progname);

   100 	exit(2);

   101 }

   102 

   103 static void

   104 main_thread(int port)

   105 {

   106 	int sock, conn, size, i;

   107 	struct sockaddr_in addr, clientaddr;

   108 

   109 	sock = socket(PF_INET, SOCK_STREAM, 0);

   110 	if (sock < 0) {

   111 		oprogname();

   112 		perror("can't create socket");

   113 		exit(1);

   114 	}

   115 

   116 #ifdef SO_REUSEADDR

   117 	i = 1;

   118 	setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *) &i, sizeof i);

   119 #endif

   120 

   121 	memset((char *)&addr, '\0', sizeof addr);

   122 	addr.sin_family = AF_INET;

   123 	addr.sin_port = htons(port);

   124 	addr.sin_addr.s_addr = 0L;

   125 	if (bind(sock, (struct sockaddr *)&addr, sizeof addr) < 0) {

   126 		oprogname();

   127 		perror("can't bind socket to address");

   128 		exit(1);

   129 	}

   130 

   131 	if (listen(sock, 5) < 0) {

   132 		oprogname();

   133 		perror("can't listen on socket");

   134 		exit(1);

   135 	}

   136 

   137 	fprintf(stderr, "Listening on port %d...\n", port);

   138 

   139 	for (i = 0; ; i++) {

   140 		size = sizeof clientaddr;

   141 		memset((char *) &clientaddr, '\0', size);

   142 		conn = accept(sock, (struct sockaddr *) &clientaddr, &size);

   143 		if (conn < 0) {

   144 			oprogname();

   145 			perror("can't accept connection from socket");

   146 			exit(1);

   147 		}

   148 

   149 		size = sizeof addr;

   150 		memset((char *) &addr, '\0', size);

   151 		if (getsockname(conn, (struct sockaddr *)&addr, &size) < 0) {

   152 			oprogname();

   153 			perror("can't get socket name of connection");

   154 			exit(1);

   155 		}

   156 		if (clientaddr.sin_addr.s_addr != addr.sin_addr.s_addr) {

   157 			oprogname();

   158 			perror("connection from non-local host refused");

   159 			fprintf(stderr, "(addr=%lx, clientaddr=%lx)\n",

   160 				ntohl(addr.sin_addr.s_addr),

   161 				ntohl(clientaddr.sin_addr.s_addr));

   162 			close(conn);

   163 			continue;

   164 		}

   165 		if (i == 4) {

   166 			close(conn);

   167 			break;

   168 		}

   169 		create_thread(conn, &clientaddr);

   170 	}

   171 

   172 	close(sock);

   173 

   174 	if (gtstate) {

   175 		PyEval_AcquireThread(gtstate);

   176 		gtstate = NULL;

   177 		Py_Finalize();

   178 		/* And a second time, just because we can. */

   179 		Py_Finalize(); /* This should be harmless. */

   180 	}

   181 	exit(0);

   182 }

   183 

   184 static void

   185 create_thread(int conn, struct sockaddr_in *addr)

   186 {

   187 	struct workorder *work;

   188 	pthread_t tdata;

   189 

   190 	work = malloc(sizeof(struct workorder));

   191 	if (work == NULL) {

   192 		oprogname();

   193 		fprintf(stderr, "out of memory for thread.\n");

   194 		close(conn);

   195 		return;

   196 	}

   197 	work->conn = conn;

   198 	work->addr = *addr;

   199 

   200 	init_python();

   201 

   202 	if (pthread_create(&tdata, NULL, (void *)service_thread, work) < 0) {

   203 		oprogname();

   204 		perror("can't create new thread");

   205 		close(conn);

   206 		return;

   207 	}

   208 

   209 	if (pthread_detach(tdata) < 0) {

   210 		oprogname();

   211 		perror("can't detach from thread");

   212 	}

   213 }

   214 

   215 static PyThreadState *the_tstate;

   216 static PyInterpreterState *the_interp;

   217 static PyObject *the_builtins;

   218 

   219 static void

   220 init_python(void)

   221 {

   222 	if (gtstate)

   223 		return;

   224 	Py_Initialize(); /* Initialize the interpreter */

   225 	PyEval_InitThreads(); /* Create (and acquire) the interpreter lock */

   226 	gtstate = PyEval_SaveThread(); /* Release the thread state */

   227 }

   228 

   229 static void *

   230 service_thread(struct workorder *work)

   231 {

   232 	FILE *input, *output;

   233 

   234 	fprintf(stderr, "Start thread for connection %d.\n", work->conn);

   235 

   236 	ps();

   237 

   238 	input = fdopen(work->conn, "r");

   239 	if (input == NULL) {

   240 		oprogname();

   241 		perror("can't create input stream");

   242 		goto done;

   243 	}

   244 

   245 	output = fdopen(work->conn, "w");

   246 	if (output == NULL) {

   247 		oprogname();

   248 		perror("can't create output stream");

   249 		fclose(input);

   250 		goto done;

   251 	}

   252 

   253 	setvbuf(input, NULL, _IONBF, 0);

   254 	setvbuf(output, NULL, _IONBF, 0);

   255 

   256 	run_interpreter(input, output);

   257 

   258 	fclose(input);

   259 	fclose(output);

   260 

   261   done:

   262 	fprintf(stderr, "End thread for connection %d.\n", work->conn);

   263 	close(work->conn);

   264 	free(work);

   265 }

   266 

   267 static void

   268 oprogname(void)

   269 {

   270 	int save = errno;

   271 	fprintf(stderr, "%s: ", progname);

   272 	errno = save;

   273 }

   274 

   275 static void

   276 run_interpreter(FILE *input, FILE *output)

   277 {

   278 	PyThreadState *tstate;

   279 	PyObject *new_stdin, *new_stdout;

   280 	PyObject *mainmod, *globals;

   281 	char buffer[1000];

   282 	char *p, *q;

   283 	int n, end;

   284 

   285 	PyEval_AcquireLock();

   286 	tstate = Py_NewInterpreter();

   287 	if (tstate == NULL) {

   288 		fprintf(output, "Sorry -- can't create an interpreter\n");

   289 		return;

   290 	}

   291 

   292 	mainmod = PyImport_AddModule("__main__");

   293 	globals = PyModule_GetDict(mainmod);

   294 	Py_INCREF(globals);

   295 

   296 	new_stdin = PyFile_FromFile(input, "<socket-in>", "r", NULL);

   297 	new_stdout = PyFile_FromFile(output, "<socket-out>", "w", NULL);

   298 

   299 	PySys_SetObject("stdin", new_stdin);

   300 	PySys_SetObject("stdout", new_stdout);

   301 	PySys_SetObject("stderr", new_stdout);

   302 

   303 	for (n = 1; !PyErr_Occurred(); n++) {

   304 		Py_BEGIN_ALLOW_THREADS

   305 		fprintf(output, "%d> ", n);

   306 		p = fgets(buffer, sizeof buffer, input);

   307 		Py_END_ALLOW_THREADS

   308 

   309 		if (p == NULL)

   310 			break;

   311 		if (p[0] == '\377' && p[1] == '\354')

   312 			break;

   313 

   314 		q = strrchr(p, '\r');

   315 		if (q && q[1] == '\n' && q[2] == '\0') {

   316 			*q++ = '\n';

   317 			*q++ = '\0';

   318 		}

   319 

   320 		while (*p && isspace(*p))

   321 			p++;

   322 		if (p[0] == '#' || p[0] == '\0')

   323 			continue;

   324 

   325 		end = run_command(buffer, globals);

   326 		if (end < 0)

   327 			PyErr_Print();

   328 

   329 		if (end)

   330 			break;

   331 	}

   332 

   333 	Py_XDECREF(globals);

   334 	Py_XDECREF(new_stdin);

   335 	Py_XDECREF(new_stdout);

   336 

   337 	Py_EndInterpreter(tstate);

   338 	PyEval_ReleaseLock();

   339 

   340 	fprintf(output, "Goodbye!\n");

   341 }

   342 

   343 static int

   344 run_command(char *buffer, PyObject *globals)

   345 {

   346 	PyObject *m, *d, *v;

   347 	fprintf(stderr, "run_command: %s", buffer);

   348 	if (strchr(buffer, '\n') == NULL)

   349 		fprintf(stderr, "\n");

   350 	v = PyRun_String(buffer, Py_single_input, globals, globals);

   351 	if (v == NULL) {

   352 		if (PyErr_Occurred() == PyExc_SystemExit) {

   353 			PyErr_Clear();

   354 			return 1;

   355 		}

   356 		PyErr_Print();

   357 		return 0;

   358 	}

   359 	Py_DECREF(v);

   360 	return 0;

   361 }

   362 

   363 static void

   364 ps(void)

   365 {

   366 	char buffer[100];

   367 	PyOS_snprintf(buffer, sizeof(buffer),

   368 		      "ps -l -p %d </dev/null | sed 1d\n", getpid());

   369 	system(buffer);

   370 }