import socket
import struct

sock = socket.socket()
sock.connect(('vortex.labs.pulltheplug.org', 5842))

len = 4

in_data = sock.recv(len)

print in_data

>>> from struct import *
>>>print unpack('I',in_data)

import socket
import struct

sock = socket.socket()
sock.connect(('vortex.labs.pulltheplug.org', 5842))

len_int = 4
in_data = sock.recv(len_int)
result = struct.unpack('<I',in_data)
print result

import socket
import struct
from struct import *
sock = socket.socket()
sock.connect(('vortex.labs.pulltheplug.org', 5842))
len_int = 4
i = 0
sum = 0
while (i != 4):
 num = unpack('<I',sock.recv(len_int))
 print num[0]
 sum += num[0]
 i += 1

print sum
sock.send(pack('<I',sum))
print sock.recv(1024)
sock.close()

wargame$ python test1.py 
83808278
183050462
24982680
1273023711
1564865131
Username: vortex1 Password: **********

struct packet {
	unsigned char ops;
	unsigned short int id;
	unsigned short int flags;
	unsigned int assoc;
} __attribute__((__packed__));
typedef struct packet packet;

struct data_assoc {
	unsigned short int len;
	unsigned char buf[0];
} __attribute__((__packed__));
typedef struct data_assoc data_assoc;

class Packet(object):
    def __init__(self, ops=None, id=None, flags=None, assoc=None, bytes=None):
        self.ops = ops
        self.id = id
        self.flags = flags
        self.assoc = assoc
        if bytes:
            self.fromBytes(bytes)

    def fromBytes(self, bytes):
        # little-endian
        (self.ops, self.id, self.flags, self.assoc) = struct.unpack("<BHHI", bytes)

    def toBytes(self):
        # little-endian
        return struct.pack("<BHHI", self.ops, self.id, self.flags, self.assoc)

    def __len__(self):
        return struct.calcsize("<BHHI")

    def __repr__(self):
        return "ops %d, id %d, flags %d, assoc %d " % (self.ops, self.id, self.flags, self.assoc)

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        input = raw_input("ops, id, flags, assoc: ")
        [ops, id, flags, assoc] = input.split(",")
        header = Header(int(ops.strip()), int(id.strip()), int(flags.strip()), int(assoc.strip())) 
        p_out = Packet(header)
        sock.sendto(p_out.toBytes(), ADDR) # hit breakpoint
        data, addr = sock.recvfrom(PKTSIZE)
        p_in = Packet(bytes=data)        
        print repr(p_in)
        sock.close()

drifter3@games $ ./level3.py
out = ops, id, flags, assoc: 0,0,0,0
in = ops 0, id 0, flags 1, assoc 3696333875

sock.send(pack('<I',sum))

sock.send(pack('<q',sum))

sock.send(pack('<Q',sum))

#include<stdio.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<stdlib.h>
#include<netdb.h>
#include<string.h>

#define PORTNO 24000
#define MAXLEN 10000

int main()
{
	char buffer[MAXLEN+1];
	int mysocket,len,i;
	struct sockaddr_in mydest;
	mysocket = socket(PF_INET,SOCK_STREAM,0);
	mydest.sin_family = AF_INET;
	mydest.sin_port = htons(PORTNO);
	mydest.sin_addr.s_addr = inet_addr("69.55.233.89");
	connect(mysocket,(struct sockaddr*)&mydest,sizeof(struct sockaddr));
	len = recv(mysocket,buffer,MAXLEN,0);
        for(i=0;i<len;i++)
	         printf("%d\n",buffer[i]);
	close(buffer);
	return EXIT_SUCCESS;
}

import sys
from struct import *
from socket import *
mysocket = socket(AF_INET, SOCK_STREAM)
mysocket.connect(("vortex.labs.overthewire.org", 5842))
buffer_ = ''
while len(buffer_) < 16:
	buffer_ = buffer_ + mysocket.recv(4)

print len(buffer_)
print buffer_
intlist = unpack("IIII", buffer_)
print intlist
result = sum(intlist)
print result
mysocket.send(pack("Q", result))
print mysocket.recv(10000)