The class:

 
package nl.debit.net.bonjour
{
	import flash.events.TimerEvent;
	import flash.net.DatagramSocket;
	import flash.utils.ByteArray;
	import flash.utils.Timer;
 
	public class DaapAnnouncer
	{
		private var _aSocket:DatagramSocket;
		private var _ip:String;
		private var _port:int;
		private var _ttl:int;
 
		private var _name:String;
		private var _timer:Timer;
 
		public function DaapAnnouncer(name:String, ip:String, port:int = 3689, ttl:int = 120)
		{
			_name = name;
			_ip = ip;
			_port = port;
			_ttl = ttl;
 
			init();
		}
 
		private function init():void
		{
			_aSocket = new DatagramSocket();
 
			_timer = new Timer((_ttl / 2) * 1000);
			_timer.addEventListener(TimerEvent.TIMER, sendAnnounceData);
			_timer.start();
			sendAnnounceData(null);
		}
 
		private function sendAnnounceData(event:TimerEvent):void
		{
			_aSocket.send(getAnnounceBytes(_ttl),0,0,"224.0.0.251",5353);
		}
 
		public function start():void
		{
			if(_timer.running)
				return;
 
			_timer.start();
			sendAnnounceData(null);
		}
 
		public function stop():void
		{
			_timer.stop();
			_aSocket.send(getAnnounceBytes(0),0,0,"224.0.0.251",5353);
		}
 
		public function dispose():void
		{
			stop();
			_timer.removeEventListener(TimerEvent.TIMER, sendAnnounceData);
			_timer = null;
			_aSocket = null;
		}
 
		private function getAnnounceBytes(ttl:int):ByteArray
		{
			var bytes:ByteArray = new ByteArray();
 
			bytes.writeShort(0x00); // Transaction ID: 0x0000
			bytes.writeShort(0x8400); // Flags
			bytes.writeShort(0x00); // Question
			bytes.writeShort(0x03); // Answer RRs
			bytes.writeShort(0x00); // Authority RRs
			bytes.writeShort(0x01); // Additional RRs
 
			writeString(bytes, _name + "._daap._tcp.local");
			bytes.writeByte(0x00);
 
			//SRV record
			bytes.writeShort(0x21); //Type
			bytes.writeByte(0x80); // FlushCache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl); //Time to live
			bytes.writeShort(8 + _ip.length); //Data length
			bytes.writeShort(0x00); //priority
			bytes.writeShort(0x00); //weight
			bytes.writeShort(_port); //port
			writeString(bytes, _ip);
			bytes.writeByte(0x00); //end
 
			//TXT Record
			bytes.writeShort(0xC00C); //Name ^^^
			bytes.writeShort(0x10); //Type TXT
			bytes.writeByte(0x80); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl);//TTL
			bytes.writeShort(0x01); //Data length
			bytes.writeByte(0x00); //Data
 
			//PTR Record
			bytes.writeByte(0xC0);
			bytes.writeByte(0x0D + _name.length);
			bytes.writeShort(0x0C); //Type PTR
			bytes.writeByte(0x00); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl);//TTL
			bytes.writeShort(0x02); //Data length
			bytes.writeShort(0xC00C); //Data 
 
			//Additional Record
			bytes.writeShort(0xC00C); //Name ^^^
			bytes.writeShort(0x2F); //Type NSEC
			bytes.writeByte(0x80); //Flush Cache
			bytes.writeByte(0x01); // Class IN
			bytes.writeUnsignedInt(ttl); //TTL
			bytes.writeShort(0x09); //Data length
			bytes.writeShort(0xC00C); //Data Next domain name
			bytes.writeUnsignedInt(0x50000); //Dunno
			bytes.writeByte(0x80); // RR type TXT
			bytes.writeByte(0x00);
			bytes.writeByte(0x40); // RR type SRV
 
			return bytes;
		}
 
		private function writeString(bytes:ByteArray, string:String):void
		{
			var ar:Array = string.split(".");
			var len:int = ar.length;
 
			for (var i:int = 0; i < len; i++)
			{
				bytes.writeByte((ar[i] as String).length);
				bytes.writeUTFBytes(ar[i]);
			}
		}
	}
}
 

The code needs some cleaning but I think the idea is obvious.

A Simple AIR example: download

Alchemy C:

#include
#include 
 
#include "AS3.h"
 
static AS3_Val readFile(void* self, AS3_Val args)
{
	char * fileName;
	FILE * file;
	long fileSize;
	char * buffer;
 
	AS3_ArrayValue(args, "StrType", &fileName);
 
	file = fopen(fileName,"rb");
 
	//Get file size
	fseek (file, 0, SEEK_END);
	fileSize = ftell(file);
	rewind(file);
 
	//Allocate buffer
	buffer = (char*) malloc(sizeof(char)*fileSize);
 
	//Read file into buffer
	fread(buffer, 1, fileSize, file);
 
	//close file and free allocated buffer
	fclose (file);
	free (buffer);
 
	return AS3_String((char*)buffer);
}
 
int main()
{
	AS3_Val readMethod = AS3_Function(NULL, readFile);
 
	AS3_Val result = AS3_Object("readFile: AS3ValType", readMethod);
 
	AS3_Release(readMethod);
	AS3_LibInit(result);
 
	return 0;
}

Actionscript:

package
{
	import cmodule.dataTest1.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		public function Main()
		{
 
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var byteArray:ByteArray = new ByteArray();
			byteArray.writeUTFBytes("Hello World!");
 
			loader.supplyFile("testFile.txt", byteArray);
 
			trace(lib.readFile("testFile.txt"));
		}
	}
}

The method of reading a "file" as shown above is read-only in C. That's not because I opened the file "rb" (Read Binary) that's just the way it is. But as you can see it's a really simple solution to read data in C. The bytearray you provide can be any bytearray you like, for example: data from a FileReference.
The filename is a unique identifier for the bytearray. You could just use fopen("testFile.txt","rb") in C and not give the filename as an argument.

Memory allocation in C with direct access in Actionscript (FAST!!)

Alchemy C:

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
 
#include "AS3.h"
 
unsigned char* buffer;
int bufferSize;
 
static AS3_Val initByteArray(void* self, AS3_Val args)
{
 
	AS3_ArrayValue(args, "IntType", &bufferSize);
 
	//Allocate buffer of size "bufferSize"
	buffer = (unsigned char*)malloc(bufferSize*sizeof(char));
 
	//return pointer to the location in memory
	return AS3_Int((int)buffer);
}
 
static AS3_Val writeData(void* self, AS3_Val args)
{
	char *tempBuffer;
	AS3_ArrayValue(args, "StrType", &tempBuffer);
 
	//copy string to buffer
	strcpy((char*)buffer, (char*)tempBuffer);
 
	return AS3_String((char*)tempBuffer);
}
 
static AS3_Val clearByteArray(void* self, AS3_Val args)
{
	//free the buffer
	free(buffer);
	*buffer = 0;
	return 0;
}
 
int main()
{
	AS3_Val initByteArrayMethod = AS3_Function(NULL, initByteArray);
	AS3_Val writeDataMethod = AS3_Function(NULL, writeData);
	AS3_Val clearByteArrayMethod = AS3_Function(NULL, clearByteArray);
 
	AS3_Val result = AS3_Object("initByteArray:AS3ValType, writeData:AS3ValType, clearByteArray:AS3ValType", initByteArrayMethod, writeDataMethod, clearByteArrayMethod);
 
	AS3_Release(initByteArrayMethod);
	AS3_Release(writeDataMethod);
	AS3_Release(clearByteArrayMethod);
	AS3_LibInit(result);
 
	return 0;
}

Actionscript:

package
{
	import cmodule.dataTest2.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		private var _dataPosition:uint;
 
		public function Main()
		{
 
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var ns:Namespace = new Namespace("cmodule.dataTest2");
			var byteArray:ByteArray = (ns::gstate).ds; //point to memory
 
			_dataPosition = lib.initByteArray(12); //This is the position of the data in memory			
 
			lib.writeData("Hello "); //example function to write data in C
 
			byteArray.position = _dataPosition + 6; //Move to the next free location
 
			byteArray.writeUTFBytes("World!"); //write text at the current position
 
			byteArray.position = _dataPosition; //reset position
 
			trace(byteArray.readUTFBytes(12));//read bytearray
 
			lib.clearByteArray(); //Free the bytearray
		}
	}
}

This method is the fastest method to use data between C and Actionscript. In C you allocate a chunk of memory of the given size and it's position is returned to Actionscript. In Actionscript you can set a reference to the Alchemy memory as shown with the namespace.
You MUST postition the bytearray to the position given back by C, because that's where your data is.

I've tested this method with coloring a 640x400px bitmap looping over the rainbow colors.
I applied the bytearray to the bitmap with setPixels(ba:ByteArray, rect:Rectangle); and filled the 640x400 bytearray in both Actionscript and C. I was very surprised about the difference in speed.
In Actionscript the framerate maxed out at 10fps, but filling the bytearray in C gave me a rate of 60fps (max on my mac).

funopen and bytearray pointer

Alchemy C:

#include <stdlib.h>
#include <stdio.h>
 
#include "AS3.h"
 
/* Does a FILE * read against a ByteArray */
static int readByteArray(void *cookie, char *dst, int size)
{
	return AS3_ByteArray_readBytes(dst, (AS3_Val)cookie, size);
}
 
/* Does a FILE * write against a ByteArray */
static int writeByteArray(void *cookie, const char *src, int size)
{
	return AS3_ByteArray_writeBytes((AS3_Val)cookie, (char *)src, size);
}
 
/* Does a FILE * lseek against a ByteArray */
static fpos_t seekByteArray(void *cookie, fpos_t offs, int whence)
{
	return AS3_ByteArray_seek((AS3_Val)cookie, offs, whence);
}
 
/* Does a FILE * close against a ByteArray */
static int closeByteArray(void * cookie)
{
	AS3_Val zero = AS3_Int(0);
 
	/* just reset the position */
	AS3_SetS((AS3_Val)cookie, "position", zero);
	AS3_Release(zero);
	return 0;
}
 
static AS3_Val doMagic(void* self, AS3_Val args)
{
	FILE * file;
	long fileSize;
	char * buffer;
	void * dest;
 
	AS3_ArrayValue(args, "AS3ValType", &dest);
 
	file = funopen((void *)dest, readByteArray, writeByteArray, seekByteArray, closeByteArray);
 
	char buffer2[] = {'H','e','l','l','o',' ','W','o','r','l','d','!'};
 
	fwrite (buffer2, 1, sizeof(buffer2), file);
 
	// get file size
	fseek (file, 0, SEEK_END);
	fileSize = ftell(file);
	rewind (file);
 
	//Allocate memory for the buffer
	buffer = (char*) malloc (sizeof(char)*fileSize);
 
	//Copy the file into the buffer
	fread (buffer, 1, fileSize, file);
 
	//Close file and clear
	fclose (file);
	free (buffer);
 
	return AS3_String(buffer);
}
 
int main()
{
	AS3_Val doMagicMethod = AS3_Function(NULL, doMagic);
 
	AS3_Val result = AS3_Object("doMagic:AS3ValType", doMagicMethod);
 
	AS3_Release(doMagicMethod);
	AS3_LibInit(result);
 
	return 0;
}

ActionScript:

package
{
	import cmodule.dataTest3.CLibInit;
 
	import flash.display.Sprite;
	import flash.utils.ByteArray;		
 
	public class Main extends Sprite
	{
		public function Main()
		{
			var loader:CLibInit = new CLibInit();
			var lib:Object = loader.init();
 
			var byteArray:ByteArray = new ByteArray();
 
			var result:String = lib.doMagic(byteArray);
 
			trace(result);
			trace(byteArray.readUTFBytes(byteArray.length));
		}
	}
}

As you can see you pass a ByteArray to C and it uses funopen to open the bytearray as a FILE. The functions provided at the funopen function map the FILE functions to bytearray functions, so the bytearray acts as a file.
In ActionScript you can see that the bytearray holds the data C has writen to it.
This way you can use normal FILE function in C and for example save the data in Actionscript with the FileReference.

If you have any questions or remarks please let me hear them!