Extending & Embedding Python

[Marco Meoni]

Hi all! I've a problem with a C++ class that has to be included in a
python application. One way to do it is Extending and Embedding the
Python Interpreter
Now i have 2 questions
1) Is there a one-file version of this tutorial?
2) Is there anyone that can help me with this problem? The class is
attached.

Thanks all.
Marco

Attached files:
------------------------------------------------------------------------------------------------------
#ifndef _PACKETMANAGER_H_
#define _PACKETMANAGER_H_
#include "Cipher/Cipher.h"

#define PAYLOAD_LENGHT 5000

//the our defined packe over the UDP datagram
struct packet {
	int lenght; // sizeof(payload) = sizeof(int) + strlen(payload)
	unsigned char payload[PAYLOAD_LENGHT]; // the xml string
} __attribute__ ((packed));


//! manage the send and receive of udp packet
/*! by default: send message non-cripted */
class PacketManager
{
	private:
		struct packet packet_to_send;
		Cipher * pc;
		int s;	//socket descriptor
	public:
		PacketManager();
		virtual ~PacketManager();

		///Network member function
		bool send(char * IPdest , int port_to);
		unsigned char * receive (char * IPdest, int timeout);  //non-blocking
		unsigned char * waitMessage(char * IPfrom); //blocking

		///Packet Builder member function
		bool build_Packet();
		bool setCipher(Cipher * c);
		Cipher * getCipher();

		///Set and Get function on all attributes

		bool set_Payload(unsigned char * c, int lenght);
		unsigned char  * get_Payload();

		bool set_packet_lenght(unsigned int lenght);
		unsigned int get_packet_lenght();

		void set_Socket(int socket);
		int get_Socket();
		bool buildPacket();
		void setSocket(int socket);
		packet getPacket();
		bool setPacket(unsigned char * c,int lenght);
		void closeSocket();
};

#endif //_PACKETMANAGER_H_
---------------------------------------------------------------------------------------------------
#include "Cipher/Cipher.h"
#include "Cipher/NullCipher.h"

#include "PacketManager.h"

#include "messages.h"

#define PORT_FROM 40004

//! manage the send and receive of udp packet
/*! by default: send message non-cripted */
PacketManager::PacketManager()
{

	pc =  new NullCipher();

	s = create_UDP_socket(PORT_FROM);

}

PacketManager::~PacketManager()
{
	close (s);
	delete pc;
}

void PacketManager::setSocket(int socket)
{
	s = socket;
}

bool PacketManager::buildPacket()
{
	pc->encrypt(); 													//! ciphering
	return true;

}

Cipher * PacketManager::getCipher()
{
	return pc;
}

bool PacketManager::setCipher(Cipher * c)
{
	pc=c;
	return true;
}

//! send payload + header to IPdest at port_to
/*! send payload + header in an UDP packet
\param IPdest address to witch send the packet
\param port_to port to witch send the packet
 */
bool PacketManager::send(char *IPdest,int port_to)

{


	//unsigned char * message_to_send = new unsigned
char(packet_to_send.lenght * sizeof(unsigned char));
	unsigned char message_to_send[5000];

         memcpy (message_to_send, &(packet_to_send.lenght) ,
sizeof(int));

	 unsigned char * tmp_payload = message_to_send;
	 tmp_payload+=sizeof(int);

memcpy(tmp_payload,packet_to_send.payload,strlen((char*)packet_to_send.payload));

      // memcpy (message_to_send + sizeof(int), packet_to_send.payload,
packet_to_send.lenght - sizeof(int));                        //! mess =
[int][payload]



	//memcpy (message_to_send, &packet_to_send ,sizeof (struct
packet));			//! mess = [packet_to_send]

 	 packet_to_send.payload[packet_to_send.lenght-4]='\0';

	 printf ("Sto per inviare:  \nlenght = \t%d \nPayload = \t%s\n",
packet_to_send.lenght , packet_to_send.payload);

	message_to(s,port_to,IPdest, message_to_send , packet_to_send.lenght
);

	//delete message_to_send;

	//return 0;

	return true;
}

//! wait for a packet, non blocking, don't check for IP
/*! wait for a packet, non blocking, don't check for IP
 * param IPdest should be the IP from witch receive files
 * param timeout should be the seconds to wait until a message was
received
 */
unsigned char * PacketManager::receive(char *IPdest, int timeout)
{
	info risposta;
	risposta  = wait_message(s);
														//!have to check if the message return from IPdest
	return risposta.message;

}

//! wait for a packet from IPfrom, blocking
/*! wait for a packet from IPfrom, blocking, with check on IP
\param IPfrom the IP of the machine you want to wait for
 */
unsigned char * PacketManager::waitMessage(char *IPfrom)
{

	info mess_received;
	bool b = false;

	while (b == false )
	{
		mess_received = wait_message(s);

		in_addr_t ip_manager;		//!check if the message return from IPdest
		ip_manager = inet_addr(IPfrom);
		unsigned char * ip_man = new unsigned char(4);
		ip_man = (unsigned char * ) &ip_manager;
																//check
		if ( ip_man[0] == mess_received.ip[0] &&	\
				   ip_man[1] == mess_received.ip[1] &&  	\
				   ip_man[2] == mess_received.ip[2] &&	\
				   ip_man[3] == mess_received.ip[3] 	\
		   )
			b = true;

	}

	return mess_received.message;

}

bool PacketManager::setPacket(unsigned char * c,int lenght)
{
	//strcpy ((char *) payload, (char *) c);								//! with strcpy you
can't have \0 in middle of a payload, or it will be truncated

	memcpy(packet_to_send.payload,c,lenght);
	packet_to_send.lenght = lenght + sizeof (int);


	return true;
}

packet PacketManager::getPacket()
{
	return packet_to_send;
}

void PacketManager::closeSocket(){

	close(s);
}
--------------------------------------------------------------------------------------------