1-2:erl fygrave$ cat socket_proxy.erl
-module(socket_proxy).

-export([
	 start/4,
	 server/3,
	 process/1,
         loop/2
]).
%
% once compiled, start it like socket_proxy:start(20, 1222, "somehost", 22).
%
start(Num,LPort, Host, DPort) ->
    case gen_tcp:listen(LPort,[{active, true},{packet,0}]) of
        {ok, ListenSock} ->
            start_servers(Num,ListenSock, Host, DPort),
            {ok, Port} = inet:port(ListenSock),
            Port;
        {error,Reason} ->
            {error,Reason}
    end.
start_servers(0,_, _, _) ->
    ok;
start_servers(Num,LS, Host, DPort) ->
    spawn(?MODULE,server,[LS, Host, DPort]),
    start_servers(Num-1,LS, Host, DPort).
server(LS, Host, DPort) ->
    io:format("Server started ~n"),
    case gen_tcp:accept(LS) of
        {ok,S} ->
            io:format("Got connect ~n"),
            case gen_tcp:connect(Host, DPort,
				 [binary, 
		     {packet,0},
		     {active, true}
                    ]
				) of
		{ok, Socket} ->
		    loop(S,Socket),
		    server(LS,Host, DPort);
		E ->
		    io:format("Error:Connect failed!~n"),
		    E
		end,
		ok;
        Other ->
            io:format("Error: accept returned ~w - finita!~n",[Other]),
            ok
    end.
loop(S,Socket) ->
    inet:setopts(S,[{active,once}]),
    receive
        {tcp,S,Data} ->
	    io:format("Received tcp ~p ~n",[Data]),
            Ret = process(Data), % you can poke around with the data
            gen_tcp:send(Socket,Ret),
            loop(S, Socket); % erlang awesomeness. no loops ;)
        {tcp,Socket,Data} ->
            io:format("Received tcp(S) ~p ~n", [Data]),
            Ret = process(Data),
            gen_tcp:send(S, Ret),
            loop(S,Socket);
        {tcp_closed,S} ->
            gen_tcp:close(Socket),
            io:format("Socket ~w closed [~w]~n",[S,self()]),
            ok;
        {tcp_closed, Socket}->
            gen_tcp:close(S),
            io:format("Socket (S) ~w closed [~w]~n",[S,self()]),
            ok
	
    end.

process(Data) ->
    io:format("Process data: ~p ~n", [ Data]),
    Data.

def decode_chunked(data):
    offset = 0
    encdata = ''
    newdata = ''
    offset = string.index(data, "\r\n\r\n") + 4 # get the offset 
    # of the data payload. you can also parse content-length header as well.
    encdata =data[offset:]
    try:
        while (encdata != ''):
            off = int(encdata[:string.index(encdata,"\r\n")],16)
            if off == 0:
                break
            encdata = encdata[string.index(encdata,"\r\n") + 2:]
            newdata = "%s%s" % (newdata, encdata[:off])
            encdata = encdata[off+2:]
                             
    except:
       line = traceback.format_exc()
       print "Exception! %s" %line # probably indexes are wrong
    return newdata