int avahi_server_add_dns_server_address(
AvahiServer *s,
AvahiSEntryGroup *g,
AvahiIfIndex interface,
AvahiProtocol protocol,
AvahiPublishFlags flags,
const char *domain,
AvahiDNSServerType type,
const AvahiAddress *address,
uint16_t port /** should be 53 */) {
AvahiRecord *r;
char n[64], h[64];
AvahiEntry *a_entry, *s_entry;
assert(s);
assert(address);
AVAHI_CHECK_VALIDITY(s, AVAHI_IF_VALID(interface), AVAHI_ERR_INVALID_INTERFACE);
AVAHI_CHECK_VALIDITY(s, AVAHI_PROTO_VALID(protocol) && AVAHI_PROTO_VALID(address->proto), AVAHI_ERR_INVALID_PROTOCOL);
AVAHI_CHECK_VALIDITY(s, AVAHI_FLAGS_VALID(flags, AVAHI_PUBLISH_USE_MULTICAST|AVAHI_PUBLISH_USE_WIDE_AREA), AVAHI_ERR_INVALID_FLAGS);
AVAHI_CHECK_VALIDITY(s, type == AVAHI_DNS_SERVER_UPDATE || type == AVAHI_DNS_SERVER_RESOLVE, AVAHI_ERR_INVALID_FLAGS);
AVAHI_CHECK_VALIDITY(s, port != 0, AVAHI_ERR_INVALID_PORT);
AVAHI_CHECK_VALIDITY(s, !domain || avahi_is_valid_domain_name(domain), AVAHI_ERR_INVALID_DOMAIN_NAME);
if (!domain)
domain = s->domain_name;
transport_flags_from_domain(s, &flags, domain);
AVAHI_CHECK_VALIDITY(s, flags & AVAHI_PUBLISH_USE_MULTICAST, AVAHI_ERR_NOT_SUPPORTED);
if (address->proto == AVAHI_PROTO_INET) {
hexstring(h, sizeof(h), &address->data, sizeof(AvahiIPv4Address));
snprintf(n, sizeof(n), "ip-%s.%s", h, domain);
r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_A, AVAHI_DEFAULT_TTL_HOST_NAME);
r->data.a.address = address->data.ipv4;
} else {
hexstring(h, sizeof(h), &address->data, sizeof(AvahiIPv6Address));
snprintf(n, sizeof(n), "ip6-%s.%s", h, domain);
r = avahi_record_new_full(n, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_AAAA, AVAHI_DEFAULT_TTL_HOST_NAME);
r->data.aaaa.address = address->data.ipv6;
}
if (!r)
return avahi_server_set_errno(s, AVAHI_ERR_NO_MEMORY);
a_entry = server_add_internal(s, g, interface, protocol, AVAHI_PUBLISH_UNIQUE | AVAHI_PUBLISH_ALLOW_MULTIPLE, r);
avahi_record_unref(r);
if (!a_entry)
return avahi_server_errno(s);
if (!(s_entry = server_add_dns_server_name(s, g, interface, protocol, flags, domain, type, n, port))) {
if (!(flags & AVAHI_PUBLISH_UPDATE))
avahi_entry_free(s, a_entry);
return avahi_server_errno(s);
}
return AVAHI_OK;
}
//------------------------------------------------------------------------
void notmain ( void )
{
//unsigned int ra;
switch_to_80Mhz();
uart_init();
hexstring(0x87654321);
hexstring(0x12345678);
//Cortex-M4 systick timer init
PUT32(STCTRL,0x00000004);
PUT32(STRELOAD,1000000-1);
PUT32(STCURRENT,0); //value is a dont care
PUT32(STCTRL,0x00000005);
while(1)
{
uart_send(0x55);
dowait();
uart_send(0x56);
dowait();
}
}
signed PLCTopologyPrint (struct plctopology * plctopology)
{
signed plcnetworks = plctopology->plcnetworks;
struct plcnetwork * plcnetwork = (struct plcnetwork *)(&plctopology->plcnetwork);
while (plcnetworks--)
{
signed plcstations = plcnetwork->plcstations;
struct plcstation * plcstation = (struct plcstation *)(&plcnetwork->plcstation);
while (plcstations--)
{
char address [ETHER_ADDR_LEN * 3];
printf ("%s ", plcstation->LOC? "LOC": "REM");
printf ("%s ", plcstation->CCO? "CCO": "STA");
printf ("%03d ", plcstation->TEI);
printf ("%s ", hexstring (address, sizeof (address), plcstation->MAC, sizeof (plcstation->MAC)));
printf ("%s ", hexstring (address, sizeof (address), plcstation->BDA, sizeof (plcstation->BDA)));
printf ("%03d ", plcstation->RX);
printf ("%03d ", plcstation->TX);
printf ("%s ", plcstation->hardware);
printf ("%s ", plcstation->firmware);
printf ("\n");
plcstation++;
}
plcnetwork = (struct plcnetwork *)(plcstation);
}
return (0);
}
void notmain ( void ) {
uart_init();
hexstring(0x12345678);
hexstring(GETPC());
timer_init();
/*
* 132 byte packet. All fields are 1 byte except for the 128 byte data
* payload.
* +-----+------+----------+--....----+-----+
* | SOH | blk# | 255-blk# | ..data.. | cksum |
* +-----+------+----------+--....----+-----+
* Protocol:
* - first block# = 1.
* - CRC is over the whole packet
* - after all packets sent, sender transmits a single EOT (must ACK).
*/
unsigned char block = 1;
unsigned addr = ARMBASE;
while (1) {
unsigned char b;
// We received an EOT, send an ACK, jump to beginning of code
if((b = getbyte()) == EOT) {
uart_send(ACK);
BRANCHTO(ARMBASE);
return; // NOTREACHED
}
/*
* if first byte is not SOH, or second byte is not the
* expected block number or the third byte is not its
* negation, send a nak for a resend of this block.
*/
if(b != SOH
|| getbyte() != block
|| getbyte() != (0xFF - block)) {
uart_send(NAK);
continue;
}
// get the data bytes
int i;
unsigned char cksum;
for(cksum = i = 0; i < PAYLOAD_SIZE; i++) {
cksum += (b = getbyte());
PUT8(addr+i, b);
}
// Checksum failed: NAK the block
if(getbyte() != cksum)
uart_send(NAK);
// Commit our addr pointer and go to next block.
else {
uart_send(ACK);
addr += PAYLOAD_SIZE;
block++;
}
}
}
//-------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
unsigned int rb;
uart_init();
hexstring(0x12345678);
PUT32(GPIO0_GPIODIR,0xFF);
PUT32(TIMER0_CONTROL,0x00);
PUT32(TIMER0_LOAD,0x000FFFFF);
PUT32(TIMER0_INTCLR,0);
PUT32(TIMER0_CONTROL,0xC2);
for(ra=0;ra<5;)
{
rb=GET32(TIMER0_RIS);
if(rb)
{
PUT32(GPIO0_BASE+(0xFF<<2),ra);
PUT32(TIMER0_INTCLR,0);
hexstring(ra);
ra++;
}
}
PUT32(GPIO0_BASE+(0xFF<<2),0xFF);
PUT32(GPIO0_BASE+(0xFF<<2),0x00);
PUT32(GPIO0_BASE+(0xFF<<2),0xFF);
PUT32(GPIO0_BASE+(0xFF<<2),0x00);
PUT32(GPIO0_BASE+(0xFF<<2),0xFF);
return(0);
}
//-------------------------------------------------------------------------
void swi_code ( unsigned int inst, unsigned int sp )
{
hexstring(inst);
hexstring(sp);
hexstring(GET32(sp+0x0));
hexstring(GET32(sp+0x4));
hexstring(GET32(sp+0x8));
}
//-------------------------------------------------------------------
void notmain ( void )
{
pll_init();
uart_init();
hexstring(0x12345678,1);
hexstring(0x12345678,1);
}
void * tbuf_malloc ( unsigned int len )
{
void *ret;
// ret=(void *)&heap_data[heap_off];
ret=(void *)heap_off;
if(heap_off>=0x40007F00) { hexstring(heap_off,0); hexstring(GETSP(),1); }
return(ret);
}
unsigned short notmain ( void )
{
uart_init();
hexstring(0x1234);
if(limit_test()) hexstring(0xBAD);
hexstring(0x1234);
return(0);
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
unsigned int rb;
leds_off();
uart_init();
hexstring(0x12345678);
hexstring(GETPC());
hexstring(GETCPSR());
hexstring(GETSCTLR());
hexstring(GETMPIDR());
hexstring(GET32(0x1000));
hexstring(GET32(0x1004));
hexstring(GET32(0x1008));
if(1)
{
for(ra=0x000; ra<0x1000; ra+=4)
{
rb=GET32(ra);
if(rb)
{
hexstrings(ra);
hexstring(rb);
}
}
}
return(0);
}
void handler ( void )
{
unsigned int ra;
hexstring(GET_APSR());
hexstring(GET_IPSR());
hexstring(GET_EPSR());
hexstring(GET_CONTROL());
hexstring(SP_PROCESS());
hexstring(SP_MAIN());
hexstring(GET_SP());
ra=GET_SP();
for(;ra<0x20001000;ra+=4)
{
hexstrings(ra);
hexstring(GET32(ra));
}
ra=SP_PROCESS();
for(;ra<0x20000D00;ra+=4)
{
hexstrings(ra);
hexstring(GET32(ra));
}
iwait();
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
uart_init();
hexstring(0x12345678);
hexstring(GETPC());
//e12fff1e bx lr
//ee100f10 mrc 15, 0, r0, cr0, cr0, {0}
//ee100f30 mrc 15, 0, r0, cr0, cr0, {1}
//ee100f50 mrc 15, 0, r0, cr0, cr0, {2}
//ee100f70 mrc 15, 0, r0, cr0, cr0, {3}
//ee100f90 mrc 15, 0, r0, cr0, cr0, {4}
//ee100fb0 mrc 15, 0, r0, cr0, cr0, {5}
//ee100fd0 mrc 15, 0, r0, cr0, cr0, {6}
//ee100ff0 mrc 15, 0, r0, cr0, cr0, {7}
//ee100f11 mrc 15, 0, r0, cr0, cr1, {0}
//ee100f31 mrc 15, 0, r0, cr0, cr1, {1}
//ee100f51 mrc 15, 0, r0, cr0, cr1, {2}
//ee100f71 mrc 15, 0, r0, cr0, cr1, {3}
//ee100f91 mrc 15, 0, r0, cr0, cr1, {4}
//ee100fb1 mrc 15, 0, r0, cr0, cr1, {5}
//ee100fd1 mrc 15, 0, r0, cr0, cr1, {6}
//ee100ff1 mrc 15, 0, r0, cr0, cr1, {7}
//ee100f12 mrc 15, 0, r0, cr0, cr2, {0}
//ee100f32 mrc 15, 0, r0, cr0, cr2, {1}
//ee100f52 mrc 15, 0, r0, cr0, cr2, {2}
//ee100f72 mrc 15, 0, r0, cr0, cr2, {3}
//ee100f92 mrc 15, 0, r0, cr0, cr2, {4}
//ee100fb2 mrc 15, 0, r0, cr0, cr2, {5}
//ee100fd2 mrc 15, 0, r0, cr0, cr2, {6}
//ee100ff2 mrc 15, 0, r0, cr0, cr2, {7}
for(ra=0;ra<8;ra++)
{
PUT32(0x4000,0xee100f10|(ra<<5));
PUT32(0x4004,0xe12fff1e);
hexstrings(ra);
hexstring(BRANCHTO(0x4000));
}
for(ra=0;ra<8;ra++)
{
PUT32(0x4000,0xee100f11|(ra<<5));
PUT32(0x4004,0xe12fff1e);
hexstrings(ra);
hexstring(BRANCHTO(0x4000));
}
for(ra=0;ra<8;ra++)
{
PUT32(0x4000,0xee100f12|(ra<<5));
PUT32(0x4004,0xe12fff1e);
hexstrings(ra);
hexstring(BRANCHTO(0x4000));
}
return(0);
}
//-------------------------------------------------------------------
void notmain ( void )
{
disable_watchdog();
hexstring(0x12345678);
uart_string("Hello World!\r\n");
hexstring(0x12345678);
while(1)
{
uart_putc(uart_getc());
}
}
static bool process_data(
InputStream *is, char *buf, size_t buf_size, size_t len,
struct File *file, FILE *fp, const char **error)
{
MD5_CTX md5_ctx;
char digest_str[2*DS + 1];
size_t total = 0;
/* Compute MD5 hash of contents */
MD5_Init(&md5_ctx);
while (len > 0)
{
total += len;
MD5_Update(&md5_ctx, buf, len);
len = is->read(is, buf, buf_size);
}
MD5_Final(file->data.digest, &md5_ctx);
hexstring(digest_str, file->data.digest, DS);
if (fp != NULL)
{
fprintf(fp, "%s (%d blocks)\n",
digest_str, (int)(total/BS + (bool)(total%BS)) );
}
file->type = FILE_DATA;
return true;
}
int evalCommand(char buffer[], int x, int y){
char cmd[100];
char arg[100];
int i;
i = 0;
while(buffer[i] != '\0' && buffer[i] != ' ' && i < 100){
cmd[i] = buffer[i];
i++;
}
hexstring(i);
cmd[i + 1] = '\0';
i++;
int i0;
i0 = i;
while(buffer[i] != '\0' && buffer[i] != ' ' && i < 200){
arg[i-i0] = buffer[i];
i++;
}
uart_puts(cmd);
uart_puts("\r\n");
uart_puts(arg);
if(strcmp(cmd,"echo")){
uart_puts("echoing\r\n");
drawString(arg,x,y);
y+= 16;
}
i=0;
for(i=0; i<100; i++){
cmd[i] = 0;
arg[i] = 0;
}
return y;
}
//-------------------------------------------------------------------
void notmain ( void )
{
unsigned int ra;
hexstring(0x12345678);
PUT32(0x44e000AC,0x40002);
ra=GET32(0x4804C134);
ra&=~(1<<21);
ra&=~(1<<22);
ra&=~(1<<23);
ra&=~(1<<24);
PUT32(0x4804C134,ra);
PUT32(0x4804C194,0xA<<21);
PUT32(0x44E0007C,0x40002);
PUT32(0x4804C194,0xB<<21);
PUT32(0x4804A038,0x00000003);
PUT32(0x4804C194,0xC<<21);
ra=0;
while(1)
{
ra=(ra+1)&0xF;
PUT32(0x4804C190,((~ra)&0xF)<<21);
PUT32(0x4804C194,(ra&0xF)<<21);
delay();
}
}
//------------------------------------------------------------------------
static void send_data ( unsigned int data )
{
//PUT32(GPSET0,1<<25); //D/C = 1 for data
//spi_one_byte(data);
i2c_start();
if(i2c_write_byte(PADDR))
{
i2c_stop();
hexstring(0xBADBAD00);
return;
}
//not continuing
//want D/C a one
if(i2c_write_byte(0x40))
{
//i2c_stop();
//hexstring(0xBADBAD00);
//return;
}
if(i2c_write_byte(data))
{
//i2c_stop();
//hexstring(0xBADBAD00);
//return;
}
i2c_stop();
}
std::string argstring(int nargs, const idc_value_t args[])
{
std::string buf;
for (int i=0 ; i<nargs ; i++)
{
if (i)
buf += ", ";
switch(args[i].vtype)
{
case VT_LONG: buf+=hexstring(args[i].num); break;
case VT_STR: buf+=std::string("\"")+args[i].str+"\""; break;
case VT_FLOAT: buf+=dblstring(args[i].e); break;
case VT_WILD: buf+="..."; break;
// todo: implement these value types
case VT_OBJ: buf+="?obj?"; break;
case VT_FUNC: buf+="?func?"; break;
case VT_STR2: buf+="?str2?"; break;
case VT_PVOID: buf+="?pvoid?"; break;
case VT_INT64: buf+="?i64?"; break;
case VT_REF: buf+="?ref?"; break;
default:
buf+="???";
}
}
return buf;
}
//------------------------------------------------------------------------
//static unsigned int i2c_read_byte ( unsigned int *b )
//{
//unsigned int ra;
//unsigned int rb;
//i2c_delay();
//sda_input();
//rb=0;
//for(ra=0;ra<9;ra++)
//{
//i2c_delay();
//scl_high();
//i2c_delay();
//rb<<=1;
//if(sda_read()) rb|=1;
//i2c_delay();
//scl_low();
//i2c_delay();
//}
//sda_output();
//i2c_delay();
//ra=rb&1;
//*b=rb>>1;
//return(ra);
//}
//------------------------------------------------------------------------
static void send_command ( unsigned int cmd )
{
// PUT32(GPCLR0,1<<25); //D/C = 0 for command
//spi_one_byte(cmd);
i2c_start();
if(i2c_write_byte(PADDR))
{
i2c_stop();
hexstring(0xBADBAD00);
return;
}
//not continuing
//want D/C a zero
if(i2c_write_byte(0x00))
{
//i2c_stop();
//hexstring(0xBADBAD00);
//return;
}
if(i2c_write_byte(cmd))
{
//i2c_stop();
//hexstring(0xBADBAD00);
//return;
}
i2c_stop();
}
static void enumerate ()
{
struct nic nics [16];
struct nic * nic;
unsigned count = hostnics (nics, sizeof (nics) / sizeof (struct nic));
for (nic = nics; count--; nic++)
{
byte memory [ETHER_ADDR_LEN];
char string [ETHER_ADDR_LEN * 3];
memset (memory, 0x00, sizeof (memory));
if (!memcmp (memory, nic->ethernet, sizeof (memory)))
{
continue;
}
memset (memory, 0xFF, sizeof (memory));
if (!memcmp (memory, nic->ethernet, sizeof (memory)))
{
continue;
}
printf (" %d", nic->ifindex);
printf (" %s", hexstring (string, sizeof (string), nic->ethernet, sizeof (nic->ethernet)));
printf (" %s", decstring (string, sizeof (string), nic->internet, sizeof (nic->internet)));
printf (" %s", nic->ifname);
printf (" %s", nic->ifdesc);
printf ("\n");
}
return;
}
//------------------------------------------------------------------------
void notmain ( void )
{
unsigned int ra;
uart_init();
hexstring(0x87654321);
switch_to_mosc();
hexstring(0x12345678);
while(1)
{
ra=uart_recv();
if(ra==0x0D) uart_send(0x0A);
uart_send(ra);
}
}
//-------------------------------------------------------------------------
unsigned int SFGTS_test ( unsigned int a, unsigned int b )
{
unsigned int ret;
ret=SFGTS(a,b);
hexstrings(a); hexstrings(b); hexstring(ret);
return(ret);
}
int notmain ( void )
{
unsigned int beg,end;
unsigned int one,two;
uart_init();
hexstring(0x12345678);
IRQEN();
FIQEN();
PUT32(TIMER1_MATCH,0xFFF);
PUT32(TIMER_CONTROL,0x0C02);
beg=GET32(0xD1000000);
if(onetime()) return(1);
end=GET32(0xD1000000);
hexstring(end-beg);
one=end-beg;
hexstring(0x12345678);
cache_enable();
beg=GET32(0xD1000000);
if(onetime()) return(1);
end=GET32(0xD1000000);
hexstring(end-beg);
two=end-beg;
hexstring(0x12345678);
hexstring(one-two);
hexstring(0x12345678);
return(0);
}
int onetime ( void )
{
unsigned int ra;
unsigned int rc;
int ret;
unsigned long reslen;
unsigned long complen;
mallocoff=0x40100000;
complen=CHUNK;
ret = compress(bin,&complen,testdata,TESTDATALEN);
hexstring(ret);
hexstring(complen);
for(rc=0,ra=0;ra<complen;ra++) rc+=bin[ra];
hexstring(rc);
reslen=CHUNK;
ret = uncompress(bout,&reslen,bin,complen);
hexstring(ret);
hexstring(reslen);
ret=0;
for(ra=0;ra<TESTDATALEN;ra++)
{
if(testdata[ra]!=bout[ra]) ret++; // printf("%04X %02X %02X\n",ra,testdata[ra],bout[ra]);
}
hexstring(ret);
hexstring(mallocoff);
return(ret);
}
void kernel_main(void)
{
uart_init();
for(volatile int i=0; i<0x110A; i++);
uart_puts("init\n");
// Register the various file systems
libfs_init();
// List devices
vfs_list_devices();
// Default device
FILE *f = fopen("/boot/rpi-boot.cfg", "r");
uart_puts("f :");
hexstring((unsigned int)f);
FILE *f2 = fopen("_ceu_led.bin", "r");
uart_puts("f2 :");
hexstring((unsigned int)f2);
if (f2 != NULL) {
long flen = fsize(f);
char *buf = (char *)malloc(flen+1);
buf[flen] = 0; // null terminate
fread(buf, 1, flen, f);
fclose(f);
if (buf[0]=='m' &&
buf[1]=='u' &&
buf[2]=='l' &&
buf[3]=='t' &&
buf[4]=='i') {
{
#define GPFSEL1 ((unsigned int*)0x20200004)
#define GPSET0 ((unsigned int*)0x2020001C)
#define GPCLR0 ((unsigned int*)0x20200028)
unsigned int ra;
ra = *GPFSEL1;
ra = ra & ~(7<<18);
ra = ra | 1<<18;
*GPFSEL1 = ra;
*GPCLR0 = 1<<16; // GPIO16 on
while(1);
}
}
}
}
/* make_ssl_debug(unsigned char *buf, char *msg, int len)
Generic debug function using hexstring()
*/
void
make_ssl_debug ( unsigned char *buf, char *msg, int len )
{
char *h;
h=hexstring ( ( unsigned char * ) buf, len );
printf ( "%s: %s (length %d)\n", msg, h, len );
free ( h );
}
//------------------------------------------------------------------------
int notmain ( void )
{
unsigned int ra;
uart_init();
hexstring(0x12345678);
for(ra=0;ra<10;ra++)
{
hexstring(ra);
}
spi_init();
PUT32(AUX_SPI0_CS,0x00400000); //cs1 low, reset
for(ra=0;ra<0x10000;ra++) dummy(ra);
prog_avr();
PUT32(AUX_SPI0_CS,0x00000000); //cs1 comes back up
hexstring(0x12345678);
return(0);
}//-------------------------------------------------------------------------
int
TAO_System_Id_With_Multiple_Id_Strategy::bind_using_system_id (
PortableServer::Servant servant,
CORBA::Short priority,
TAO_Active_Object_Map_Entry *&entry)
{
ACE_NEW_RETURN (entry,
TAO_Active_Object_Map_Entry,
-1);
int result =
this->active_object_map_->user_id_map_->bind_create_key (entry,
entry->user_id_);
if (result == 0)
{
entry->servant_ = servant;
entry->priority_ = priority;
result = this->active_object_map_->id_hint_strategy_->bind (*entry);
if (result != 0)
{
this->active_object_map_->user_id_map_->unbind (entry->user_id_);
delete entry;
}
#if defined (TAO_HAS_MONITOR_POINTS) && (TAO_HAS_MONITOR_POINTS == 1)
this->active_object_map_->monitor_->receive (
this->active_object_map_->user_id_map_->current_size ());
#endif /* TAO_HAS_MONITOR_POINTS==1 */
}
else
{
delete entry;
}
#if (TAO_HAS_MINIMUM_CORBA == 0)
if (result == 0 && TAO_debug_level > 7)
{
CORBA::String_var idstr (
PortableServer::ObjectId_to_string (entry->user_id_));
CORBA::String_var repository_id (
servant ? servant->_repository_id () : 0);
ACE_CString hex_idstr;
hexstring (hex_idstr, idstr.in (), entry->user_id_.length ());
TAOLIB_DEBUG ((LM_DEBUG,
"TAO (%P|%t) - TAO_System_Id_With_Multiple_Id_Strategy::"
"bind_using_system_id: type=%C, id=%C\n",
repository_id.in (),
hex_idstr.c_str()
));
}
#endif
return result;
}
void fun_jmp ()
{
INT16
offs;
offs = getint16 (infile);
dumpint ( (UNS16) offs);
printf ("jmp [%s]\n",
hexstring ((size_t)(ftell(infile) + offs), 4));
}
//-------------------------------------------------------------------
void notmain ( void )
{
PUT32(MAMCR,0);
PUT32(MAMTIM,2); //20MHz
PUT32(MAMCR,2);
PUT32(APBDIV,1);
uart_init();
hexstring(0x12345678,1);
}
