eventmachine 0.4.2 → 0.4.3

data/ext/cmain.cpp

@@ -51,10 +51,10 @@ evma_release_library
 
 extern "C" void evma_release_library()
 {
-  if (!EventMachine)
-    throw std::runtime_error ("not initialized");
-  delete EventMachine;
-  EventMachine = NULL;
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	delete EventMachine;
+	EventMachine = NULL;
 }
 
 
@@ -105,6 +105,18 @@ extern "C" const char *evma_create_tcp_server (const char *address, int port)
 	return EventMachine->CreateTcpServer (address, port);
 }
 
+/*************************
+evma_open_datagram_socket
+*************************/
+
+extern "C" const char *evma_open_datagram_socket (const char *address, int port)
+{
+	if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return EventMachine->OpenDatagramSocket (address, port);
+}
+
+
 
 /****************************
 evma_send_data_to_connection
@@ -117,6 +129,17 @@ extern "C" int evma_send_data_to_connection (const char *binding, const char *da
 	return ConnectionDescriptor::SendDataToConnection (binding, data, data_length);
 }
 
+/******************
+evma_send_datagram
+******************/
+
+extern "C" int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port)
+{
+  if (!EventMachine)
+		throw std::runtime_error ("not initialized");
+	return DatagramDescriptor::SendDatagram (binding, data, data_length, address, port);
+}
+
 
 /*********************
 evma_close_connection
@@ -143,4 +166,3 @@ extern "C" void evma_stop_machine()
 
 
 
-

data/ext/ed.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.cpp 2291 2006-04-14 03:56:18Z francis $
+$Id: ed.cpp 2363 2006-04-23 14:32:40Z francis $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -122,6 +122,19 @@ bool EventableDescriptor::ShouldDelete()
 }
 
 
+/**********************************
+EventableDescriptor::ScheduleClose
+**********************************/
+
+void EventableDescriptor::ScheduleClose (bool after_writing)
+{
+	if (after_writing)
+		bCloseAfterWriting = true;
+	else
+		bCloseNow = true;
+}
+
+
 /******************************************
 ConnectionDescriptor::ConnectionDescriptor
 ******************************************/
@@ -152,8 +165,14 @@ STATIC: ConnectionDescriptor::SendDataToConnection
 
 int ConnectionDescriptor::SendDataToConnection (const char *binding, const char *data, int data_length)
 {
-  ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-  return cd ? cd->SendOutboundData (data, data_length) : -1;
+	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
+	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
+	if (cd)
+		return cd->SendOutboundData (data, data_length);
+	DatagramDescriptor *ds = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
+	if (ds)
+		return ds->SendOutboundData (data, data_length);
+	return -1;
 }
 
 
@@ -163,13 +182,10 @@ STATIC: ConnectionDescriptor::CloseConnection
 
 void ConnectionDescriptor::CloseConnection (const char *binding, bool after_writing)
 {
-	ConnectionDescriptor *cd = dynamic_cast <ConnectionDescriptor*> (Bindable_t::GetObject (binding));
-	if (cd) {
-		if (after_writing)
-			cd->bCloseAfterWriting = true;
-		else
-			cd->bCloseNow = true;
-	}
+	// TODO: This is something of a hack, or at least it's a static method of the wrong class.
+	EventableDescriptor *ed = dynamic_cast <EventableDescriptor*> (Bindable_t::GetObject (binding));
+	if (ed)
+		ed->ScheduleClose (after_writing);
 }
 
 
@@ -180,23 +196,24 @@ ConnectionDescriptor::SendOutboundData
 
 int ConnectionDescriptor::SendOutboundData (const char *data, int length)
 {
-  // Highly naive and incomplete implementation.
-  // There's no throttle for runaways (which should abort only this connection
-  // and not the whole process), and no coalescing of small pages.
-
-  if (bCloseNow || bCloseAfterWriting)
-    return 0;
-
-  if (!data && (length > 0))
-    throw std::runtime_error ("bad outbound data");
-  char *buffer = (char *) malloc (length + 1);
-  if (!buffer)
-    throw std::runtime_error ("no allocation for outbound data");
-  memcpy (buffer, data, length);
-  buffer [length] = 0;
-  OutboundPages.push_back (OutboundPage (buffer, length));
-  OutboundDataSize += length;
-  return length;
+	// Highly naive and incomplete implementation.
+	// There's no throttle for runaways (which should abort only this connection
+	// and not the whole process), and no coalescing of small pages.
+	// (Well, not so bad, small pages are coalesced in ::Write)
+
+	if (bCloseNow || bCloseAfterWriting)
+		return 0;
+
+	if (!data && (length > 0))
+		throw std::runtime_error ("bad outbound data");
+	char *buffer = (char *) malloc (length + 1);
+	if (!buffer)
+		throw std::runtime_error ("no allocation for outbound data");
+	memcpy (buffer, data, length);
+	buffer [length] = 0;
+	OutboundPages.push_back (OutboundPage (buffer, length));
+	OutboundDataSize += length;
+	return length;
 }
 
 
@@ -276,7 +293,12 @@ void ConnectionDescriptor::Read()
 			total_bytes_read += r;
 			LastRead = gCurrentLoopTime;
 
-			readbuffer [r] = 0; // Impute a null-terminator, just for convenience.
+			// Add a null-terminator at the the end of the buffer
+			// that we will send to the callback.
+			// DO NOT CHANGE THIS. We want to explicitly allow users
+			// to be able to depend on this behavior, so they will have
+			// the option to do some things faster.
+			readbuffer [r] = 0;
 
 			if (EventCallback)
 				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_READ, readbuffer, r);
@@ -465,37 +487,37 @@ void AcceptorDescriptor::Read()
 	for (int i=0; i < 10; i++) {
 		int sd = accept (GetSocket(), (struct sockaddr*)&pin, &addrlen);
 		if (sd == -1) {
-      // This breaks the loop when we've accepted everything on the kernel queue,
-      // up to 10 new connections. But what if the *first* accept fails?
-      // Does that mean anything serious is happening, beyond the situation
-      // described in the note above?
+			// This breaks the loop when we've accepted everything on the kernel queue,
+			// up to 10 new connections. But what if the *first* accept fails?
+			// Does that mean anything serious is happening, beyond the situation
+			// described in the note above?
 			break;
 		}
 
-    // Set the newly-accepted socket non-blocking.
-    // On Windows, this may fail because, weirdly, Windows inherits the non-blocking
-    // attribute that we applied to the acceptor socket into the accepted one.
+		// Set the newly-accepted socket non-blocking.
+		// On Windows, this may fail because, weirdly, Windows inherits the non-blocking
+		// attribute that we applied to the acceptor socket into the accepted one.
 		int val = fcntl (sd, F_GETFL, 0);
 		if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1) {
-      shutdown (sd, 1);
-      close (sd);
-      continue;
+			shutdown (sd, 1);
+			close (sd);
+			continue;
 		}
 
 
-    // Disable slow-start (Nagle algorithm). Eventually make this configurable.
-  	int one = 1;
-  	setsockopt (sd, IPPROTO_TCP, TCP_NODELAY, (const char*) &one, sizeof(one));
+		// Disable slow-start (Nagle algorithm). Eventually make this configurable.
+		int one = 1;
+		setsockopt (sd, IPPROTO_TCP, TCP_NODELAY, (const char*) &one, sizeof(one));
 
 
-    ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
-    if (!cd)
-      throw std::runtime_error ("no newly accepted connection");
-	if (EventCallback) {
-		(*EventCallback) (GetBinding().c_str(), EventMachine_t::CONNECTION_ACCEPTED, cd->GetBinding().c_str(), cd->GetBinding().size());
-	}
-    assert (MyEventMachine);
-    MyEventMachine->Add (cd);
+		ConnectionDescriptor *cd = new ConnectionDescriptor (sd);
+		if (!cd)
+			throw std::runtime_error ("no newly accepted connection");
+		if (EventCallback) {
+			(*EventCallback) (GetBinding().c_str(), EventMachine_t::CONNECTION_ACCEPTED, cd->GetBinding().c_str(), cd->GetBinding().size());
+		}
+		assert (MyEventMachine);
+		MyEventMachine->Add (cd);
 	}
 
 }
@@ -524,5 +546,232 @@ void AcceptorDescriptor::Heartbeat()
 
 
 
+/**************************************
+DatagramDescriptor::DatagramDescriptor
+**************************************/
+
+DatagramDescriptor::DatagramDescriptor (int sd):
+  EventableDescriptor (sd)
+{
+}
+
+
+/***************************************
+DatagramDescriptor::~DatagramDescriptor
+***************************************/
+
+DatagramDescriptor::~DatagramDescriptor()
+{
+	// Run down any stranded outbound data.
+	for (size_t i=0; i < OutboundPages.size(); i++)
+		OutboundPages[i].Free();
+}
+
+
+/************************
+DatagramDescriptor::Read
+************************/
+
+void DatagramDescriptor::Read()
+{
+	int sd = GetSocket();
+	assert (sd != -1);
+
+	// This is an extremely large read buffer.
+	// In many cases you wouldn't expect to get any more than 4K.
+	char readbuffer [16 * 1024];
+
+	for (int i=0; i < 10; i++) {
+		// Don't read just one buffer and then move on. This is faster
+		// if there is a lot of incoming.
+		// But don't read indefinitely. Give other sockets a chance to run.
+
+		struct sockaddr_in sin;
+		socklen_t slen = sizeof (sin);
+		bzero (&sin, slen);
+
+		int r = recvfrom (sd, readbuffer, sizeof(readbuffer) - 1, 0, (struct sockaddr*)&sin, &slen);
+		//cerr << "<R:" << r << ">";
+
+		// In UDP, a zero-length packet is perfectly legal.
+		if (r >= 0) {
+			LastRead = gCurrentLoopTime;
+
+			// Add a null-terminator at the the end of the buffer
+			// that we will send to the callback.
+			// DO NOT CHANGE THIS. We want to explicitly allow users
+			// to be able to depend on this behavior, so they will have
+			// the option to do some things faster.
+			readbuffer [r] = 0;
+
+
+			// Set up a "temporary" return address so that callers can "reply" to us
+			// from within the callback we are about to invoke. That means that ordinary
+			// calls to "send_data_to_connection" (which is of course misnamed in this
+			// case) will result in packets being sent back to the same place that sent
+			// us this one.
+			// There is a different call (evma_send_datagram) for cases where the caller
+			// actually wants to send a packet somewhere else.
+
+			bzero (&ReturnAddress, sizeof(ReturnAddress));
+			memcpy (&ReturnAddress, &sin, slen);
+
+			if (EventCallback)
+				(*EventCallback)(GetBinding().c_str(), EventMachine_t::CONNECTION_READ, readbuffer, r);
+
+		}
+		else {
+			// Basically a would-block, meaning we've everything there is to read.
+			break;
+		}
+
+	}
+
+
+}
+
+
+/*************************
+DatagramDescriptor::Write
+*************************/
+
+void DatagramDescriptor::Write()
+{
+	/* It's possible for a socket to select writable and then no longer
+	 * be writable by the time we get around to writing. The kernel might
+	 * have used up its available output buffers between the select call
+	 * and when we get here. So this condition is not an error.
+	 * This code is very reminiscent of ConnectionDescriptor::_WriteOutboundData,
+	 * but differs in the that the outbound data pages (received from the
+	 * user) are _message-structured._ That is, we send each of them out
+	 * one message at a time.
+	 * TODO, we are currently suppressing the EMSGSIZE error!!!
+	 */
+
+	int sd = GetSocket();
+	assert (sd != -1);
+
+	assert (OutboundPages.size() > 0);
+
+	// Send out up to 10 packets, then cycle the machine.
+	for (int i = 0; i < 10; i++) {
+		if (OutboundPages.size() <= 0)
+			break;
+		OutboundPage *op = &(OutboundPages[0]);
+
+		int s = sendto (sd, op->Buffer, op->Length, 0, (struct sockaddr*)&(op->From), sizeof(op->From));
+		int e = errno;
+
+		OutboundDataSize -= op->Length;
+		op->Free();
+		OutboundPages.pop_front();
+
+		if (s == -1) {
+			if ((e != EINPROGRESS) && (e != EWOULDBLOCK) && (e != EINTR)) {
+				Close();
+				break;
+			}
+		}
+	}
+}
+
+
+/**********************************
+DatagramDescriptor::SelectForWrite
+**********************************/
+
+bool DatagramDescriptor::SelectForWrite()
+{
+	return (GetOutboundDataSize() > 0);
+}
+
+
+/************************************
+DatagramDescriptor::SendOutboundData
+************************************/
+
+int DatagramDescriptor::SendOutboundData (const char *data, int length)
+{
+	// This is an exact clone of ConnectionDescriptor::SendOutboundData.
+	// That means it needs to move to a common ancestor.
+
+	if (bCloseNow || bCloseAfterWriting)
+		return 0;
+
+	if (!data && (length > 0))
+		throw std::runtime_error ("bad outbound data");
+	char *buffer = (char *) malloc (length + 1);
+	if (!buffer)
+		throw std::runtime_error ("no allocation for outbound data");
+	memcpy (buffer, data, length);
+	buffer [length] = 0;
+	OutboundPages.push_back (OutboundPage (buffer, length, ReturnAddress));
+	OutboundDataSize += length;
+	return length;
+}
+
+
+/****************************************
+DatagramDescriptor::SendOutboundDatagram
+****************************************/
+
+int DatagramDescriptor::SendOutboundDatagram (const char *data, int length, const char *address, int port)
+{
+	// This is an exact clone of ConnectionDescriptor::SendOutboundData.
+	// That means it needs to move to a common ancestor.
+  // TODO: Refactor this so there's no overlap with SendOutboundData.
+
+	if (bCloseNow || bCloseAfterWriting)
+		return 0;
+
+	if (!address || !*address || !port)
+		return 0;
+
+	sockaddr_in pin;
+	unsigned long HostAddr;
+
+	HostAddr = inet_addr (address);
+	if (HostAddr == -1) {
+		hostent *hp = gethostbyname (address);
+		if (!hp)
+			return 0;
+		HostAddr = ((in_addr*)(hp->h_addr))->s_addr;
+	}
+
+	memset (&pin, 0, sizeof(pin));
+	pin.sin_family = AF_INET;
+	pin.sin_addr.s_addr = HostAddr;
+	pin.sin_port = htons (port);
+
+
+
+	if (!data && (length > 0))
+		throw std::runtime_error ("bad outbound data");
+	char *buffer = (char *) malloc (length + 1);
+	if (!buffer)
+		throw std::runtime_error ("no allocation for outbound data");
+	memcpy (buffer, data, length);
+	buffer [length] = 0;
+	OutboundPages.push_back (OutboundPage (buffer, length, pin));
+	OutboundDataSize += length;
+	return length;
+}
+
+
+/****************************************
+STATIC: DatagramDescriptor::SendDatagram
+****************************************/
+
+int DatagramDescriptor::SendDatagram (const char *binding, const char *data, int length, const char *address, int port)
+{
+	DatagramDescriptor *dd = dynamic_cast <DatagramDescriptor*> (Bindable_t::GetObject (binding));
+	if (dd)
+		return dd->SendOutboundDatagram (data, length, address, port);
+  else
+    return -1;
+}
+
+
+
 
 

data/ext/ed.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: ed.h 2291 2006-04-14 03:56:18Z francis $
+$Id: ed.h 2363 2006-04-23 14:32:40Z francis $
 
 File:     ed.h
 Date:     06Apr06
@@ -41,38 +41,40 @@ class EventableDescriptor: public Bindable_t
 		EventableDescriptor (int);
 		virtual ~EventableDescriptor();
 
-    int GetSocket() {return MySocket;}
-    void Close();
+		int GetSocket() {return MySocket;}
+		void Close();
 
 		virtual void Read() = 0;
 		virtual void Write() = 0;
 		virtual void Heartbeat() = 0;
 
-    // These methods tell us whether the descriptor
-    // should be selected or polled for read/write.
-    virtual bool SelectForRead() = 0;
-    virtual bool SelectForWrite() = 0;
+		// These methods tell us whether the descriptor
+		// should be selected or polled for read/write.
+		virtual bool SelectForRead() = 0;
+		virtual bool SelectForWrite() = 0;
 
-    // are we scheduled for a close, or in an error state, or already closed?
+		// are we scheduled for a close, or in an error state, or already closed?
 		bool ShouldDelete();
-	// Do we have any data to write? This is used by ShouldDelete.
-	virtual int GetOutboundDataSize() {return 0;}
+		// Do we have any data to write? This is used by ShouldDelete.
+		virtual int GetOutboundDataSize() {return 0;}
 
-    void SetEventCallback (void (*cb)(const char*, int, const char*, int));
+		void ScheduleClose (bool after_writing);
 
-  protected:
-    enum {
-      PendingConnectTimeout = 4 // can easily be made an instance variable
-    };
+		void SetEventCallback (void (*cb)(const char*, int, const char*, int));
 
-    void (*EventCallback)(const char*, int, const char*, int);
+	protected:
+		enum {
+			PendingConnectTimeout = 4 // can easily be made an instance variable
+		};
+
+		void (*EventCallback)(const char*, int, const char*, int);
     
-    time_t CreatedAt;
-    time_t LastRead;
-    time_t LastWritten;
-    int MySocket;
-    bool bCloseNow;
-    bool bCloseAfterWriting;
+		time_t CreatedAt;
+		time_t LastRead;
+		time_t LastWritten;
+		int MySocket;
+		bool bCloseNow;
+		bool bCloseAfterWriting;
 };
 
 
@@ -83,66 +85,109 @@ class ConnectionDescriptor
 
 class ConnectionDescriptor: public EventableDescriptor
 {
-  public:
-    ConnectionDescriptor (int);
-    virtual ~ConnectionDescriptor();
+	public:
+		ConnectionDescriptor (int);
+		virtual ~ConnectionDescriptor();
 
-    static int SendDataToConnection (const char*, const char*, int);
-    static void CloseConnection (const char*, bool);
+		static int SendDataToConnection (const char*, const char*, int);
+		static void CloseConnection (const char*, bool);
 
-    int SendOutboundData (const char*, int);
+		int SendOutboundData (const char*, int);
 
-    void SetConnectPending (bool f) { bConnectPending = f; }
+		void SetConnectPending (bool f) { bConnectPending = f; }
 
 		virtual void Read();
 		virtual void Write();
 		virtual void Heartbeat();
 
-    virtual bool SelectForRead();
-    virtual bool SelectForWrite();
+		virtual bool SelectForRead();
+		virtual bool SelectForWrite();
 
-	// Do we have any data to write? This is used by ShouldDelete.
-	virtual int GetOutboundDataSize() {return OutboundDataSize;}
+		// Do we have any data to write? This is used by ShouldDelete.
+		virtual int GetOutboundDataSize() {return OutboundDataSize;}
 
-  protected:
-    struct OutboundPage {
-      OutboundPage (const char *b, int l, int o=0): Buffer(b), Length(l), Offset(o) {}
-		void Free() {if (Buffer) free ((char*)Buffer); }
-      const char *Buffer;
-      int Length;
-		int Offset;
-    };
+	protected:
+		struct OutboundPage {
+			OutboundPage (const char *b, int l, int o=0): Buffer(b), Length(l), Offset(o) {}
+			void Free() {if (Buffer) free ((char*)Buffer); }
+			const char *Buffer;
+			int Length;
+			int Offset;
+		};
 
-  protected:
-    bool bConnectPending;
+	protected:
+		bool bConnectPending;
 
-    deque<OutboundPage> OutboundPages;
-    int OutboundDataSize;
+		deque<OutboundPage> OutboundPages;
+		int OutboundDataSize;
 
 	private:
 		void _WriteOutboundData();
 };
 
 
+/************************
+class DatagramDescriptor
+************************/
+
+class DatagramDescriptor: public EventableDescriptor
+{
+	public:
+		DatagramDescriptor (int);
+		virtual ~DatagramDescriptor();
+
+		virtual void Read();
+		virtual void Write();
+		virtual void Heartbeat() {}
+
+		virtual bool SelectForRead() {return true;}
+		virtual bool SelectForWrite();
+
+		int SendOutboundData (const char*, int);
+		int SendOutboundDatagram (const char*, int, const char*, int);
+
+		// Do we have any data to write? This is used by ShouldDelete.
+		virtual int GetOutboundDataSize() {return OutboundDataSize;}
+
+		static int SendDatagram (const char*, const char*, int, const char*, int);
+
+
+	protected:
+		struct OutboundPage {
+			OutboundPage (const char *b, int l, struct sockaddr_in f, int o=0): Buffer(b), Length(l), From(f), Offset(o) {}
+			void Free() {if (Buffer) free ((char*)Buffer); }
+			const char *Buffer;
+			int Length;
+			int Offset;
+			struct sockaddr_in From;
+		};
+
+		deque<OutboundPage> OutboundPages;
+		int OutboundDataSize;
+
+		struct sockaddr_in ReturnAddress;
+};
+
+
 /************************
 class AcceptorDescriptor
 ************************/
 
 class AcceptorDescriptor: public EventableDescriptor
 {
-  public:
-    AcceptorDescriptor (EventMachine_t*, int);
-    virtual ~AcceptorDescriptor();
+	public:
+		AcceptorDescriptor (EventMachine_t*, int);
+		virtual ~AcceptorDescriptor();
 
 		virtual void Read();
 		virtual void Write();
 		virtual void Heartbeat();
 
-    virtual bool SelectForRead() {return true;}
-    virtual bool SelectForWrite() {return false;}
+		virtual bool SelectForRead() {return true;}
+		virtual bool SelectForWrite() {return false;}
 
-  protected:
-    EventMachine_t *MyEventMachine;
+	protected:
+		EventMachine_t *MyEventMachine;
 };
 
 

data/ext/em.cpp

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.cpp 2291 2006-04-14 03:56:18Z francis $
+$Id: em.cpp 2363 2006-04-23 14:32:40Z francis $
 
 File:     ed.cpp
 Date:     06Apr06
@@ -271,7 +271,7 @@ const char *EventMachine_t::ConnectToServer (const char *server, int port)
 	 * not the Solaris-style, and returns zero with the error code in
 	 * the error parameter.
 	 * Return the binding-text of the newly-created pending connection,
-   * or NULL if there was a problem.
+	 * or NULL if there was a problem.
 	 */
 
 	if (!server || !*server || !port)
@@ -351,13 +351,13 @@ EventMachine_t::CreateTcpServer
 
 const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 {
-  /* Create a TCP-acceptor (server) socket and add it to the event machine.
-   * Return the binding of the new acceptor to the caller.
-   * This binding will be referenced when the new acceptor sends events
-   * to indicate accepted connections.
-   */
+	/* Create a TCP-acceptor (server) socket and add it to the event machine.
+	 * Return the binding of the new acceptor to the caller.
+	 * This binding will be referenced when the new acceptor sends events
+	 * to indicate accepted connections.
+	 */
 
-  const char *output_binding = NULL;
+	const char *output_binding = NULL;
 
 	struct sockaddr_in sin;
 
@@ -423,7 +423,7 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 		if (!ad)
 			throw std::runtime_error ("unable to allocate acceptor");
 		Add (ad);
-    output_binding = ad->GetBinding().c_str();
+		output_binding = ad->GetBinding().c_str();
 	}
 
 	return output_binding;
@@ -435,6 +435,65 @@ const char *EventMachine_t::CreateTcpServer (const char *server, int port)
 }
 
 
+/**********************************
+EventMachine_t::OpenDatagramSocket
+**********************************/
+
+const char *EventMachine_t::OpenDatagramSocket (const char *address, int port)
+{
+	const char *output_binding = NULL;
+
+	int sd = socket (AF_INET, SOCK_DGRAM, 0);
+	if (sd == -1)
+		goto fail;
+	// from here on, early returns must close the socket!
+
+
+	struct sockaddr_in sin;
+	memset (&sin, 0, sizeof(sin));
+	sin.sin_family = AF_INET;
+	sin.sin_port = htons (port);
+
+
+	if (address && *address) {
+		sin.sin_addr.s_addr = inet_addr (address);
+		if (sin.sin_addr.s_addr == -1) {
+			hostent *hp = gethostbyname (address);
+			if (hp == NULL)
+				goto fail;
+			sin.sin_addr.s_addr = ((in_addr*)(hp->h_addr))->s_addr;
+		}
+	}
+	else
+		sin.sin_addr.s_addr = htonl (INADDR_ANY);
+
+
+	// Set the new socket nonblocking.
+	{
+		int val = fcntl (sd, F_GETFL, 0);
+		if (fcntl (sd, F_SETFL, val | O_NONBLOCK) == -1)
+			goto fail;
+	}
+
+	if (bind (sd, (struct sockaddr*)&sin, sizeof(sin)) != 0)
+		goto fail;
+
+	{ // Looking good.
+		DatagramDescriptor *ds = new DatagramDescriptor (sd);
+		if (!ds)
+			throw std::runtime_error ("unable to allocate datagram-socket");
+		Add (ds);
+		output_binding = ds->GetBinding().c_str();
+	}
+
+	return output_binding;
+
+	fail:
+	if (sd != -1)
+		close (sd);
+	return NULL;
+}
+
 
 
 /*******************

data/ext/em.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: em.h 2291 2006-04-14 03:56:18Z francis $
+$Id: em.h 2362 2006-04-23 13:57:09Z francis $
 
 File:     ed.h
 Date:     06Apr06
@@ -49,6 +49,7 @@ class EventMachine_t
 		const char *InstallOneshotTimer (int);
 		const char *ConnectToServer (const char *, int);
 		const char *CreateTcpServer (const char *, int);
+		const char *OpenDatagramSocket (const char *, int);
 
     void Add (EventableDescriptor*);
 

data/ext/eventmachine.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: eventmachine.h 2313 2006-04-15 16:12:57Z francis $
+$Id: eventmachine.h 2363 2006-04-23 14:32:40Z francis $
 
 File:     eventmachine.h
 Date:     15Apr06
@@ -37,9 +37,12 @@ extern "C" {
 	const char *evma_install_oneshot_timer (int seconds);
 	const char *evma_connect_to_server (const char *server, int port);
 	const char *evma_create_tcp_server (const char *address, int port);
+	const char *evma_open_datagram_socket (const char *server, int port);
 	int evma_send_data_to_connection (const char *binding, const char *data, int data_length);
+	int evma_send_datagram (const char *binding, const char *data, int data_length, const char *address, int port);
 	void evma_close_connection (const char *binding, int after_writing);
 	void evma_stop_machine();
+
 #if __cplusplus
 }
 #endif

data/ext/project.h

@@ -1,6 +1,6 @@
 /*****************************************************************************
 
-$Id: project.h 2291 2006-04-14 03:56:18Z francis $
+$Id: project.h 2355 2006-04-22 19:03:09Z francis $
 
 File:     project.h
 Date:     06Apr06

data/ext/rubymain.cpp

@@ -188,6 +188,17 @@ static VALUE t_send_data (VALUE self, VALUE signature, VALUE data, VALUE data_le
 }
 
 
+/***************
+t_send_datagram
+***************/
+
+static VALUE t_send_datagram (VALUE self, VALUE signature, VALUE data, VALUE data_length, VALUE address, VALUE port)
+{
+	int b = evma_send_datagram (StringValuePtr (signature), StringValuePtr (data), FIX2INT (data_length), StringValuePtr(address), FIX2INT(port));
+	return INT2NUM (b);
+}
+
+
 /******************
 t_close_connection
 ******************/
@@ -212,6 +223,18 @@ static VALUE t_connect_server (VALUE self, VALUE server, VALUE port)
 	return rb_str_new2 (f);
 }
 
+/*****************
+t_open_udp_socket
+*****************/
+
+static VALUE t_open_udp_socket (VALUE self, VALUE server, VALUE port)
+{
+	const char *f = evma_open_datagram_socket (StringValuePtr(server), FIX2INT(port));
+	if (!f || !*f)
+		rb_raise (rb_eRuntimeError, "no datagram socket");
+	return rb_str_new2 (f);
+}
+
 
 
 /*****************
@@ -251,10 +274,11 @@ extern "C" void Init_rubyeventmachine()
 	rb_define_module_function (EmModule, "add_oneshot_timer", (VALUE(*)(...))t_add_oneshot_timer, 1);
 	rb_define_module_function (EmModule, "start_tcp_server", (VALUE(*)(...))t_start_server, 2);
 	rb_define_module_function (EmModule, "send_data", (VALUE(*)(...))t_send_data, 3);
+	rb_define_module_function (EmModule, "send_datagram", (VALUE(*)(...))t_send_datagram, 5);
 	rb_define_module_function (EmModule, "close_connection", (VALUE(*)(...))t_close_connection, 2);
 	rb_define_module_function (EmModule, "connect_server", (VALUE(*)(...))t_connect_server, 2);
+	rb_define_module_function (EmModule, "open_udp_socket", (VALUE(*)(...))t_open_udp_socket, 2);
 	rb_define_module_function (EmModule, "release_machine", (VALUE(*)(...))t_release_machine, 0);
-	rb_define_module_function (EmModule, "start_server", (VALUE(*)(...))t_release_machine, 0);
 	rb_define_module_function (EmModule, "stop", (VALUE(*)(...))t_stop, 0);
 
 	// Why am I missing the rb_ function that converts a class/module name to a VALUE?

data/lib/eventmachine.rb

@@ -1,4 +1,4 @@
-# $Id: eventmachine.rb 2325 2006-04-19 16:10:00Z francis $
+# $Id: eventmachine.rb 2364 2006-04-23 16:11:13Z francis $
 #
 # Author:: blackhedd (gmail address: garbagecat20).
 # Date:: 8 Apr 2006
@@ -174,6 +174,10 @@ module EventMachine
     release_machine
   end
 
+  # EventMachine#run_without_threads is semantically identical
+  # to EventMachine#run, but it runs somewhat faster.
+  # However, it must not be used in applications that spin
+  # Ruby threads.
   def EventMachine::run_without_threads &block
     EventMachine::run false, &block
   end
@@ -494,6 +498,71 @@ module EventMachine
   end
 
 
+  # EventMachine#open_datagram_socket is for support of UDP-based
+  # protocols. Its usage is similar to that of EventMachine#start_server.
+  # It takes three parameters: an IP address (which must be valid
+  # on the machine which executes the method), a port number,
+  # and an optional Module name which will handle the data.
+  # This method will create a new UDP (datagram) socket and
+  # bind it to the address and port that you specify.
+  # The normal callbacks (see EventMachine#start_server) will
+  # be called as events of interest occur on the newly-created
+  # socket, but there are some differences in how they behave.
+  #
+  # Connection#receive_data will be called when a datagram packet
+  # is received on the socket, but unlike TCP sockets, the message
+  # boundaries of the received data will be respected. In other words,
+  # if the remote peer sent you a datagram of a particular size,
+  # you may rely on Connection#receive_data to give you the
+  # exact data in the packet, with the original data length.
+  # Also observe that Connection#receive_data may be called with a
+  # <i>zero-length</i> data payload, since empty datagrams are permitted
+  # in UDP.
+  #
+  # Connection#send_data is available with UDP packets as with TCP,
+  # but there is an important difference. Because UDP communications
+  # are <i>connectionless,</i> there is no implicit recipient for the packets you
+  # send. Ordinarily you must specify the recipient for each packet you send.
+  # However, EventMachine
+  # provides for the typical pattern of receiving a UDP datagram
+  # from a remote peer, performing some operation, and then sending
+  # one or more packets in response to the same remote peer.
+  # To support this model easily, just use Connection#send_data
+  # in the code that you supply for Connection:receive_data.
+  # EventMachine will
+  # provide an implicit return address for any messages sent to
+  # Connection#send_data within the context of a Connection#receive_data callback,
+  # and your response will automatically go to the correct remote peer.
+  # (TODO: Example-code needed!)
+  #
+  # Observe that the port number that you supply to EventMachine#open_datagram_socket
+  # may be zero. In this case, EventMachine will create a UDP socket
+  # that is bound to an <i>ephemeral</i> (not well-known) port.
+  # This is not appropriate for servers that must publish a well-known
+  # port to which remote peers may send datagrams. But it can be useful
+  # for clients that send datagrams to other servers.
+  # If you do this, you will receive any responses from the remote
+  # servers through the normal Connection#receive_data callback.
+  # Observe that you will probably have issues with firewalls blocking
+  # the ephemeral port numbers, so this technique is most appropriate for LANs.
+  # (TODO: Need an example!)
+  #
+  # If you wish to send datagrams to arbitrary remote peers (not
+  # necessarily ones that have sent data to which you are responding),
+  # then see Connection#send_datagram.
+  #
+  def self::open_datagram_socket address, port, handler=nil
+    s = open_udp_socket address, port
+    klass = Class.new( Connection ) {
+      handler and include handler
+    }
+    c = klass.new s
+    @conns[s] = c
+    block_given? and yield c
+    c
+  end
+
+
   private
   def EventMachine::event_callback conn_binding, opcode, data
     case opcode
@@ -666,6 +735,31 @@ class Connection
     EventMachine::send_data @signature, data, data.length
   end
 
+
+  # send_datagram is for sending UDP messages.
+  # This method may be called from any Connection object that refers
+  # to an open datagram socket (see EventMachine#open_datagram_socket).
+  # The method sends a UDP (datagram) packet containing the data you specify,
+  # to a remote peer specified by the IP address and port that you give
+  # as parameters to the method.
+  # Observe that you may send a zero-length packet (empty string).
+  # However, you may not send an arbitrarily-large data packet because
+  # your operating system will enforce a platform-specific limit on
+  # the size of the outbound packet. (Your kernel
+  # will respond in a platform-specific way if you send an overlarge
+  # packet: some will send a truncated packet, some will complain, and
+  # some will silently drop your request).
+  # On LANs, it's usually OK to send datagrams up to about 4000 bytes in length,
+  # but to be really safe, send messages smaller than the Ethernet-packet
+  # size (typically about 1400 bytes). Some very restrictive WANs
+  # will either drop or truncate packets larger than about 500 bytes.
+  #
+  def send_datagram data, recipient_address, recipient_port
+    data = data.to_s
+    EventMachine::send_datagram @signature, data, data.length, recipient_address, recipient_port
+  end
+
+
 end
 
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.10
 specification_version: 1
 name: eventmachine
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
-date: 2006-04-19
+  version: 0.4.3
+date: 2006-04-23
 summary: Ruby/EventMachine socket engine library
 require_paths: 
   - lib