/*
* put out the header info
*/
int put_dbf_head(dbhead_t *dbh)
{
int fd = dbh->db_fd;
struct dbf_dhead dbhead;
int ret;
memset (&dbhead, 0, sizeof(dbhead));
/* build on disk info */
dbhead.dbh_dbt = dbh->db_dbt;
put_long(dbhead.dbh_records, dbh->db_records);
put_short(dbhead.dbh_hlen, dbh->db_hlen);
put_short(dbhead.dbh_rlen, dbh->db_rlen);
/* put the date spec'd into the on disk header */
dbhead.dbh_date[DBH_DATE_YEAR] =(char)(db_date_year(dbh->db_date) -
1900);
dbhead.dbh_date[DBH_DATE_MONTH]=(char)(db_date_month(dbh->db_date));
dbhead.dbh_date[DBH_DATE_DAY] =(char)(db_date_day(dbh->db_date));
if (lseek(fd, 0, 0) < 0)
return -1;
if ((ret = write(fd, &dbhead, sizeof(dbhead))) <= 0)
return -1;
return ret;
}
DNSServiceErrorType DNSSD_API DNSServiceQueryRecord
(
DNSServiceRef *sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *name,
uint16_t rrtype,
uint16_t rrclass,
DNSServiceQueryRecordReply callBack,
void *context
)
{
char *msg = NULL, *ptr;
size_t len;
ipc_msg_hdr *hdr;
DNSServiceRef sdr;
DNSServiceErrorType err;
if (!sdRef) return kDNSServiceErr_BadParam;
*sdRef = NULL;
if (!name) name = "\0";
// calculate total message length
len = sizeof(flags);
len += sizeof(uint32_t); //interfaceIndex
len += strlen(name) + 1;
len += 2 * sizeof(uint16_t); // rrtype, rrclass
hdr = create_hdr(query_request, &len, &ptr, 1);
if (!hdr) goto error;
msg = (void *)hdr;
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(name, &ptr);
put_short(rrtype, &ptr);
put_short(rrclass, &ptr);
sdr = connect_to_server();
if (!sdr) goto error;
err = deliver_request(msg, sdr, 1);
if (err)
{
DNSServiceRefDeallocate(sdr);
return err;
}
sdr->op = query_request;
sdr->process_reply = handle_query_response;
sdr->app_callback = callBack;
sdr->app_context = context;
*sdRef = sdr;
return err;
error:
if (msg) free(msg);
if (*sdRef) { free(*sdRef); *sdRef = NULL; }
return kDNSServiceErr_Unknown;
}
/*
****************************************************************
* Envia o pedido *
****************************************************************
*/
int
send_req (SERVTB *sp, DNS *np)
{
T_UNITDATA unitdata;
INADDR addr;
struct { H h; char c[256]; } dg;
char *str;
int sz;
char area[128];
static int id;
/*
* Prepara o datagrama
*/
memset (&dg, 0, sizeof (dg));
dg.h.h_id = ENDIAN_SHORT (++id);
/*** dg.h.h_qr = 0; ***/
/*** dg.h.h_op = 0; ***/
/*** dg.h.h_aa = 0; ***/
/*** dg.h.h_tc = 0; ***/
dg.h.h_rd = 1;
/*** dg.h.h_ra = 0; ***/
/*** dg.h.h_z = 0; ***/
/*** dg.h.h_rc = 0; ***/
dg.h.h_qdcnt = ENDIAN_SHORT (1);
/*** dg.h.h_ancnt = 0; ***/
/*** dg.h.h_nscnt = 0; ***/
/*** dg.h.h_arcnt = 0; ***/
str = dg.c;
/*
* Compõe o nome reverso, se for o caso
*/
if (np->d_entry_code == 'R')
{
const char *cp = (char *)&np->d_host_addr;
#ifdef LITTLE_ENDIAN
sprintf (area, "%u.%u.%u.%u.IN-ADDR.ARPA", cp[0], cp[1], cp[2], cp[3]);
#else
sprintf (area, "%u.%u.%u.%u.IN-ADDR.ARPA", cp[3], cp[2], cp[1], cp[0]);
#endif LITTLE_ENDIAN
put_domain_name (area, &str);
}
else
{
put_domain_name (np->d_host_nm, &str);
}
if (np->d_entry_code == 'R')
put_short (TYPE_PTR, &str); /* Type = PTR */
elif (np->d_entry_code == 'M')
put_short (TYPE_MX, &str); /* Type = MX */
elif (np->d_entry_code == 'C')
put_short (TYPE_A, &str); /* Type = A */
else
return (0);
//sdRef returned by DNSServiceRegister()
DNSServiceErrorType DNSSD_API DNSServiceAddRecord
(
DNSServiceRef sdRef,
DNSRecordRef *RecordRef,
DNSServiceFlags flags,
uint16_t rrtype,
uint16_t rdlen,
const void *rdata,
uint32_t ttl
)
{
ipc_msg_hdr *hdr;
size_t len = 0;
char *ptr;
DNSRecordRef rref;
if (!sdRef || (sdRef->op != reg_service_request) || !RecordRef)
return kDNSServiceErr_BadReference;
*RecordRef = NULL;
len += 2 * sizeof(uint16_t); //rrtype, rdlen
len += rdlen;
len += sizeof(uint32_t);
len += sizeof(DNSServiceFlags);
hdr = create_hdr(add_record_request, &len, &ptr, 0);
if (!hdr) return kDNSServiceErr_Unknown;
put_flags(flags, &ptr);
put_short(rrtype, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
put_long(ttl, &ptr);
rref = malloc(sizeof(_DNSRecordRef_t));
if (!rref) goto error;
rref->app_context = NULL;
rref->app_callback = NULL;
rref->record_index = sdRef->max_index++;
rref->sdr = sdRef;
*RecordRef = rref;
hdr->client_context.context = rref;
hdr->reg_index = rref->record_index;
return deliver_request((char *)hdr, sdRef, 0);
error:
if (hdr) free(hdr);
if (rref) free(rref);
if (*RecordRef) *RecordRef = NULL;
return kDNSServiceErr_Unknown;
}
//DNSRecordRef returned by DNSServiceRegisterRecord or DNSServiceAddRecord
DNSServiceErrorType DNSSD_API DNSServiceUpdateRecord
(
DNSServiceRef sdRef,
DNSRecordRef RecordRef,
DNSServiceFlags flags,
uint16_t rdlen,
const void *rdata,
uint32_t ttl
)
{
ipc_msg_hdr *hdr;
size_t len = 0;
char *ptr;
if (!sdRef) return kDNSServiceErr_BadReference;
len += sizeof(uint16_t);
len += rdlen;
len += sizeof(uint32_t);
len += sizeof(DNSServiceFlags);
hdr = create_hdr(update_record_request, &len, &ptr, 0);
if (!hdr) return kDNSServiceErr_Unknown;
hdr->reg_index = RecordRef ? RecordRef->record_index : TXT_RECORD_INDEX;
put_flags(flags, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
put_long(ttl, &ptr);
return deliver_request((char *)hdr, sdRef, 0);
}
struct buffer *encode(struct client *c, struct packet *p) {
// Calculate the total packet length
int length = 1 + p->length;
if (p->length_type == LENGTH_BYTE)
length += 1;
else if (p->length_type == LENGTH_SHORT)
length += 2;
// Manually initialize the buffer
struct buffer *b = malloc(sizeof(struct buffer));
b->capacity = length;
b->data = malloc(length);
b->position = 0;
b->size = 0;
// Encode the packet
put_byte(b, p->opcode += isaac_next_int(c->out_cipher), X_NONE);
if (p->length_type == LENGTH_BYTE)
put_byte(b, p->length, X_NONE);
else if (p->length_type == LENGTH_SHORT)
put_short(b, p->length, ENDIAN_BIG, X_NONE);
int i;
for (i = 0; i < p->length; i++)
put_byte(b, p->payload->data[i], X_NONE);
// And produce it
return b;
}
/*
* put a field out on the disk at the current file offset
*/
int put_dbf_field(dbhead_t *dbh, dbfield_t *dbf)
{
struct dbf_dfield dbfield;
char *scp, *dcp;
int ret;
memset (&dbfield, 0, sizeof(dbfield));
/* build the on disk field info */
scp = dbf->db_fname; dcp = dbfield.dbf_name;
strlcpy(dbfield.dbf_name, dbf->db_fname, DBF_NAMELEN + 1);
dbfield.dbf_type = dbf->db_type;
switch (dbf->db_type) {
case 'N':
dbfield.dbf_flen[0] = dbf->db_flen;
dbfield.dbf_flen[1] = dbf->db_fdc;
break;
default:
put_short(dbfield.dbf_flen, dbf->db_flen);
}
/* now write it out to disk */
if ((ret = write(dbh->db_fd, &dbfield, sizeof(dbfield))) <= 0) {
return ret;
}
return 1;
}
static void copy_block(
z_stream& s,
char* buf,
size_t len,
int header )
{
bi_windup( s );
if( header )
{
put_short( s, (unsigned short) len );
put_short( s, (unsigned short) ~len );
}
while( len-- )
put_byte( s, *buf++ );
}
static void bi_windup( z_stream& s )
{
if( s.bi_valid > 8 )
put_short( s, s.bi_buf )
else if( s.bi_valid > 0 )
put_byte( s, (byte) s.bi_buf );
s.bi_buf = 0;
s.bi_valid = 0;
}
static void
output_sisheng (FILE* ofpter)
{
int i;
for (i = 0; i < jt.maxserial; i++)
{
put_short (ofpter, jeary[i]->ss);
}
}
Boolean
CDR::put_ldstring (const Short len, const String data)
{
Char *tmp = (Char *)data;
int i;
put_short (len);
for (i = 0; i < len; i++)
put_char (*tmp++);
// put_char ((Char) 0); !!! remove
return CDR_TRUE;
}
void put(PtrLen<const char> str)
{
if( str.len>=Len )
{
put_full(str.suffix(Len));
}
else
{
put_short(str);
}
}
Boolean
CDR::put_bytes (const Short len, const Ptr data)
{
Char *tmp = (Char *)data;
int i;
put_short (len + 1);
for (i = 0; i < len; i++)
put_char (*tmp++);
put_char ((Char) 0);
return CDR_TRUE;
}
DNSServiceErrorType DNSSD_API DNSServiceReconfirmRecord
(
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *fullname,
uint16_t rrtype,
uint16_t rrclass,
uint16_t rdlen,
const void *rdata
)
{
char *ptr;
size_t len;
ipc_msg_hdr *hdr;
DNSServiceRef tmp;
len = sizeof(DNSServiceFlags);
len += sizeof(uint32_t);
len += strlen(fullname) + 1;
len += 3 * sizeof(uint16_t);
len += rdlen;
tmp = connect_to_server();
if (!tmp) return(kDNSServiceErr_Unknown);
hdr = create_hdr(reconfirm_record_request, &len, &ptr, 1);
if (!hdr) return(kDNSServiceErr_Unknown);
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(fullname, &ptr);
put_short(rrtype, &ptr);
put_short(rrclass, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
ConvertHeaderBytes(hdr);
write_all(tmp->sockfd, (char *)hdr, (int) len);
free(hdr);
DNSServiceRefDeallocate(tmp);
return(kDNSServiceErr_NoError);
}
void send_bits(int value, int length, thread_context* tc)
{
tc->bits_sent += (long)length;
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
* unused bits in value.
*/
if (tc->bi_valid > (int)Buf_size - length) {
tc->bi_buf |= (value << tc->bi_valid);
put_short(tc->bi_buf);
tc->bi_buf = (ush)value >> (Buf_size - tc->bi_valid);
tc->bi_valid += length - Buf_size;
} else {
void _tr_flush_bits( z_stream& s )
{
if( s.bi_valid == 16 )
{
put_short( s, s.bi_buf );
s.bi_buf = 0;
s.bi_valid = 0;
}
else if( s.bi_valid >= 8 )
{
put_byte( s, (byte) s.bi_buf );
s.bi_buf >>= 8;
s.bi_valid -= 8;
}
static ipc_msg_hdr *create_hdr(uint32_t op, size_t *len, char **data_start, int reuse_socket)
{
char *msg = NULL;
ipc_msg_hdr *hdr;
int datalen;
#if !defined(USE_TCP_LOOPBACK)
char ctrl_path[256];
#endif
if (!reuse_socket)
{
#if defined(USE_TCP_LOOPBACK)
*len += 2; // Allocate space for two-byte port number
#else
struct timeval time;
if (gettimeofday(&time, NULL) < 0) return NULL;
sprintf(ctrl_path, "%s%d-%.3lx-%.6lu", CTL_PATH_PREFIX, (int)getpid(),
(unsigned long)(time.tv_sec & 0xFFF), (unsigned long)(time.tv_usec));
*len += strlen(ctrl_path) + 1;
#endif
}
datalen = (int) *len;
*len += sizeof(ipc_msg_hdr);
// write message to buffer
msg = malloc(*len);
if (!msg) return NULL;
bzero(msg, *len);
hdr = (void *)msg;
hdr->datalen = datalen;
hdr->version = VERSION;
hdr->op = op;
if (reuse_socket) hdr->flags |= IPC_FLAGS_REUSE_SOCKET;
*data_start = msg + sizeof(ipc_msg_hdr);
#if defined(USE_TCP_LOOPBACK)
// Put dummy data in for the port, since we don't know what
// it is yet. The data will get filled in before we
// send the message. This happens in deliver_request().
if (!reuse_socket) put_short(0, data_start);
#else
if (!reuse_socket) put_string(ctrl_path, data_start);
#endif
return hdr;
}
local void send_bits(
deflate_state *s,
sInt value, /* value to send */
sInt length) /* number of bits */
{
Tracevv((stderr," l %2d v %4x ", length, value));
Assert(length > 0 && length <= 15, "invalid length");
s->bits_sent += (ulg)length;
/* If not enough room in bi_buf, use (valid) bits from bi_buf and
* (16 - bi_valid) bits from value, leaving (width - (16-bi_valid))
* unused bits in value.
*/
if (s->bi_valid > (sInt)Buf_size - length) {
s->bi_buf |= (ush)value << s->bi_valid;
put_short(s, s->bi_buf);
s->bi_buf = (ush)value >> (Buf_size - s->bi_valid);
s->bi_valid += length - Buf_size;
} else {
/*
* output all code and labels in the peep list.
*/
void flush_peep P1 (unsigned, level)
{
register CODE *ip;
SWITCH *sw;
EXPR *ep2;
LABEL i;
opt3 (level); /* do the peephole optimizations */
for (ip = peep_head; ip != NIL_CODE; ip = ip->fwd) {
if (ip->opcode == op_label) {
put_label (ip->oper1->u.offset->v.l);
} else
put_code (ip);
}
peep_head = NIL_CODE;
for (sw = swtables; sw; sw = sw->next) {
put_kseg (alignment_of_type (tp_pointer));
put_label (sw->tablab);
ep2 = mk_lcon (UNDEF_LABEL);
/* generate the switch jump table as a series of 2-byte offsets
* This limits the amount of code that can be generated in a
* function to less then 32K. I believe that this is a reasonable
* restriction.
*/
{
EXPR *ep, *ep1;
ep1 = mk_lcon (sw->beglab);
ep = mk_node (en_sub, ep2, ep1, tp_void);
for (i = 0; i < sw->numlabs; i++) {
ep2->v.l = sw->labels[i];
put_short (ep);
}
}
}
swtables = NIL_SWITCH;
}
int write_histograms (HISTOGRAM **phisto, int nhisto, IO_BUFFER *iobuf)
{
int ihisto, mhisto, ncounts;
HISTOGRAM *histo, *thisto;
IO_ITEM_HEADER item_header;
int ibin;
if ( nhisto != - 1 )
{
if ( phisto == (HISTOGRAM **) NULL )
return -1;
if ( (histo = *phisto) == (HISTOGRAM *) NULL )
{
nhisto = 0;
item_header.ident = -1;
}
else
item_header.ident = histo->ident;
}
else
{
histo = (HISTOGRAM *) NULL;
item_header.ident = -1;
}
if ( iobuf == (IO_BUFFER *) NULL )
return -1;
item_header.type = 100; /* Histogram data is type 100 */
item_header.version = 2; /* Version 2 */
put_item_begin(iobuf,&item_header);
/* If no histogram was supplied, writing the header was the whole job. */
if ( nhisto == 0 )
{
put_short(0,iobuf);
put_item_end(iobuf,&item_header);
return 0;
}
mhisto = 0;
if ( nhisto == -1 )
{
if ( histo == (HISTOGRAM *) NULL )
histo = get_first_histogram();
thisto = histo;
while ( thisto != (HISTOGRAM *) NULL )
{
thisto = thisto->next;
mhisto++;
}
}
else
{
for ( ihisto=0; ihisto<nhisto; ihisto++ )
if ( phisto[ihisto] != (HISTOGRAM *) NULL )
mhisto++;
}
put_short(mhisto,iobuf); /* No. of histograms dumped */
for ( ihisto=0; ihisto<mhisto; ihisto++ )
{
if ( nhisto != -1 )
histo = phisto[ihisto];
#ifdef _REENTRANT
histogram_lock(histo);
#endif
put_byte((int)histo->type,iobuf);
if ( put_string(histo->title,iobuf) % 2 == 0 )
put_byte('\0',iobuf);
put_long(histo->ident,iobuf);
put_short((int)histo->nbins,iobuf);
put_short((int)histo->nbins_2d,iobuf);
put_long((long)histo->entries,iobuf);
put_long((long)histo->tentries,iobuf);
put_long((long)histo->underflow,iobuf);
put_long((long)histo->overflow,iobuf);
if ( histo->type == 'R' || histo->type == 'r' ||
histo->type == 'F' || histo->type == 'D' )
{
put_real((double)histo->specific.real.lower_limit,iobuf);
put_real((double)histo->specific.real.upper_limit,iobuf);
put_real((double)histo->specific.real.sum,iobuf);
put_real((double)histo->specific.real.tsum,iobuf);
}
else
{
put_long((long)histo->specific.integer.lower_limit,iobuf);
put_long((long)histo->specific.integer.upper_limit,iobuf);
put_long((long)histo->specific.integer.sum,iobuf);
put_long((long)histo->specific.integer.tsum,iobuf);
}
if ( histo->nbins_2d > 0 )
{
put_long((long)histo->underflow_2d,iobuf);
put_long((long)histo->overflow_2d,iobuf);
if ( histo->type == 'R' || histo->type == 'r' ||
histo->type == 'F' || histo->type == 'D' )
{
put_real((double)histo->specific_2d.real.lower_limit,iobuf);
put_real((double)histo->specific_2d.real.upper_limit,iobuf);
put_real((double)histo->specific_2d.real.sum,iobuf);
put_real((double)histo->specific_2d.real.tsum,iobuf);
}
else
{
put_long((long)histo->specific_2d.integer.lower_limit,iobuf);
put_long((long)histo->specific_2d.integer.upper_limit,iobuf);
put_long((long)histo->specific_2d.integer.sum,iobuf);
put_long((long)histo->specific_2d.integer.tsum,iobuf);
}
ncounts = histo->nbins*histo->nbins_2d;
}
else
ncounts = histo->nbins;
if ( histo->type == 'F' || histo->type == 'D' )
{
put_real((histo->extension)->content_all,iobuf);
put_real((histo->extension)->content_inside,iobuf);
put_vector_of_real((histo->extension)->content_outside,8,iobuf);
}
if ( histo->tentries > 0 ) /* FIXME: we have a problem at every multiple of exactly 2^32 entries */
{
if ( histo->type == 'F' )
for (ibin=0; ibin<ncounts; ibin++)
put_real((double)(histo->extension)->fdata[ibin],iobuf);
else if ( histo->type == 'D' )
put_vector_of_real((histo->extension)->ddata,ncounts,iobuf);
else
put_vector_of_long((long *)histo->counts,ncounts,iobuf);
}
#ifdef _REENTRANT
histogram_unlock(histo);
#endif
if ( nhisto == - 1 )
if ( (histo = histo->next) == (HISTOGRAM *) NULL )
break;
}
return(put_item_end(iobuf,&item_header));
}
static void geninittype P2 (const EXPR *, ep, unsigned char *, data)
{
TYP *tp = ep->etp;
UVAL uval;
#ifdef FLOAT_SUPPORT
RVAL rvl;
#endif /* FLOAT_SUPPORT */
UNUSEDARG (data);
switch (tp->type) {
case bt_bool:
put_char (ep);
break;
case bt_char:
case bt_charu:
case bt_uchar:
case bt_schar:
put_char (ep);
break;
case bt_short:
case bt_ushort:
case bt_int16:
case bt_uint16:
put_short (ep);
break;
case bt_pointer16:
case bt_pointer32:
break;
case bt_bitfield:
case bt_ubitfield:
case bt_bbitfield:
uval = ep->v.u & bitmask (bitfield_width (tp));
break;
case bt_int32:
case bt_uint32:
case bt_ulong:
case bt_long:
put_long (ep);
break;
case bt_struct:
break;
case bt_union:
break;
#ifdef FLOAT_SUPPORT
case bt_float:
floatexpr (tp, &rvl);
put_float (&rvl);
break;
case bt_double:
floatexpr (tp, &rvl);
put_double (&rval);
break;
case bt_longdouble:
floatexpr (tp, &rvl);
put_longdouble (&rvl);
break;
#endif /* FLOAT_SUPPORT */
case bt_func:
break;
default:
break;
}
}
CORBA_boolean
porbit_put_sv (GIOPSendBuffer *buf, CORBA_TypeCode tc, SV *sv)
{
switch (tc->kind) {
case CORBA_tk_null:
case CORBA_tk_void:
return CORBA_TRUE;
case CORBA_tk_short:
return put_short (buf, sv);
case CORBA_tk_long:
return put_long (buf, sv);
case CORBA_tk_ushort:
return put_ushort (buf, sv);
case CORBA_tk_ulong:
return put_ulong (buf, sv);
case CORBA_tk_float:
return put_float (buf, sv);
case CORBA_tk_double:
return put_double (buf, sv);
case CORBA_tk_char:
return put_char (buf, sv);
case CORBA_tk_boolean:
return put_boolean (buf, sv);
case CORBA_tk_octet:
return put_octet (buf, sv);
case CORBA_tk_enum:
return put_enum (buf, tc, sv);
case CORBA_tk_struct:
return put_struct (buf, tc, sv);
case CORBA_tk_sequence:
return put_sequence (buf, tc, sv);
case CORBA_tk_except:
return put_except (buf, tc, sv);
case CORBA_tk_objref:
return put_objref (buf, tc, sv);
case CORBA_tk_union:
return put_union (buf, tc, sv);
case CORBA_tk_alias:
return put_alias (buf, tc, sv);
case CORBA_tk_string:
return put_string (buf, tc, sv);
case CORBA_tk_array:
return put_array (buf, tc, sv);
case CORBA_tk_longlong:
return put_longlong (buf, sv);
case CORBA_tk_ulonglong:
return put_ulonglong (buf, sv);
case CORBA_tk_longdouble:
return put_longdouble (buf, sv);
case CORBA_tk_TypeCode:
return put_typecode (buf, tc, sv);
case CORBA_tk_any:
return put_any (buf, tc, sv);
case CORBA_tk_fixed:
return put_fixed (buf, tc, sv);
case CORBA_tk_wchar:
case CORBA_tk_wstring:
case CORBA_tk_Principal:
default:
warn ("Unsupported output typecode %d\n", tc->kind);
return CORBA_FALSE;
}
}
int main(int argc, char **argv)
{
int i;
int force = 1;
/* parse the options first */
for(i = 1; i < argc; i++)
{
if(argv[i][0] == '-')
{
if(argv[i][1] == '-')
{
/* continue parsing filenames */
force = i + 1;
break;
}
else if(strcmp(argv[i], "-h") == 0)
{
fprintf(stdout, "Usage: %s [-h] [-f]\n-h: display this help message\n-f: force overwriting\n", argv[0]);
return 1;
}
else if(strcmp(argv[i], "-f") == 0)
{
m_force = 1;
}
else
{
fprintf(stderr, "Unrecognized option: '%s'\n", argv[i]);
return 1;
}
}
}
/* parse the filenames */
for(i = force; i < argc; i++)
{
if(force > 1 || argv[i][0] != '-')
{
if(!compile(argv[i]))
{
fprintf(stderr, "Error compiling map '%s'\n", argv[i]);
return 1;
}
}
}
if(0)
{
/* unused function warning */
put_double(NULL, NULL);
put_float(NULL, NULL);
put_int(NULL, NULL);
put_short(NULL, NULL);
put_char(NULL, NULL);
put_cdouble(NULL, 0);
put_cfloat(NULL, 0);
put_cint(NULL, 0);
put_cshort(NULL, 0);
put_cchar(NULL, 0);
put_str(NULL, NULL, 0);
}
return 0;
}
DNSServiceErrorType DNSSD_API DNSServiceRegister
(
DNSServiceRef *sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *name,
const char *regtype,
const char *domain,
const char *host,
uint16_t PortInNetworkByteOrder,
uint16_t txtLen,
const void *txtRecord,
DNSServiceRegisterReply callBack,
void *context
)
{
char *msg = NULL, *ptr;
size_t len;
ipc_msg_hdr *hdr;
DNSServiceRef sdr;
DNSServiceErrorType err;
union { uint16_t s; u_char b[2]; } port = { PortInNetworkByteOrder };
if (!sdRef) return kDNSServiceErr_BadParam;
*sdRef = NULL;
if (!name) name = "";
if (!regtype) return kDNSServiceErr_BadParam;
if (!domain) domain = "";
if (!host) host = "";
if (!txtRecord) txtRecord = (void*)"";
// auto-name must also have auto-rename
if (!name[0] && (flags & kDNSServiceFlagsNoAutoRename))
return kDNSServiceErr_BadParam;
// no callback must have auto-rename
if (!callBack && (flags & kDNSServiceFlagsNoAutoRename)) return kDNSServiceErr_BadParam;
len = sizeof(DNSServiceFlags);
len += sizeof(uint32_t); // interfaceIndex
len += strlen(name) + strlen(regtype) + strlen(domain) + strlen(host) + 4;
len += 2 * sizeof(uint16_t); // port, txtLen
len += txtLen;
hdr = create_hdr(reg_service_request, &len, &ptr, 1);
if (!hdr) goto error;
if (!callBack) hdr->flags |= IPC_FLAGS_NOREPLY;
msg = (char *)hdr;
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(name, &ptr);
put_string(regtype, &ptr);
put_string(domain, &ptr);
put_string(host, &ptr);
*ptr++ = port.b[0];
*ptr++ = port.b[1];
put_short(txtLen, &ptr);
put_rdata(txtLen, txtRecord, &ptr);
sdr = connect_to_server();
if (!sdr) goto error;
err = deliver_request(msg, sdr, 1);
if (err)
{
DNSServiceRefDeallocate(sdr);
return err;
}
sdr->op = reg_service_request;
sdr->process_reply = callBack ? handle_regservice_response : NULL;
sdr->app_callback = callBack;
sdr->app_context = context;
*sdRef = sdr;
return err;
error:
if (msg) free(msg);
if (*sdRef) { free(*sdRef); *sdRef = NULL; }
return kDNSServiceErr_Unknown;
}
int write_test1(TEST_DATA *data, IO_BUFFER *iobuf)
{
IO_ITEM_HEADER item_header;
int i;
item_header.type = 99; /* test data */
item_header.version = 0; /* Version 0 (test) */
item_header.ident = 123;
put_item_begin(iobuf,&item_header);
put_long(data->lvar[0],iobuf);
put_long(data->lvar[1],iobuf);
put_long((long)data->ilvar[0],iobuf);
put_long((long)data->ilvar[1],iobuf);
put_short(data->isvar[0],iobuf);
put_short(data->isvar[1],iobuf);
put_short(data->svar[0],iobuf);
put_short(data->svar[1],iobuf);
put_short(data->svar[2],iobuf);
put_real(data->fvar[0],iobuf);
put_real(data->fvar[1],iobuf);
put_double(data->dvar[0],iobuf);
put_double(data->dvar[1],iobuf);
put_sfloat(data->hvar[0],iobuf);
put_sfloat(data->hvar[1],iobuf);
put_byte(data->i8var[0],iobuf);
put_byte(data->i8var[1],iobuf);
put_byte(data->u8var[0],iobuf);
put_byte(data->u8var[1],iobuf);
put_short(data->i16var[0],iobuf);
put_short(data->i16var[1],iobuf);
put_short(data->u16var[0],iobuf);
put_short(data->u16var[1],iobuf);
put_int32(data->i32var[0],iobuf);
put_int32(data->i32var[1],iobuf);
put_uint32(data->u32var[0],iobuf);
put_uint32(data->u32var[1],iobuf);
#ifdef HAVE_64BIT_INT
put_vector_of_int64(&data->i64var[0],1,iobuf);
put_vector_of_int64(&data->i64var[1],1,iobuf);
put_vector_of_uint64(&data->u64var[0],1,iobuf);
put_vector_of_uint64(&data->u64var[1],1,iobuf);
#endif
put_count(data->nbvar,iobuf);
put_byte(data->bvar[0],iobuf);
put_byte(data->bvar[1],iobuf);
for (i=0; i<4; i++)
put_count16(data->cnt16var[i],iobuf);
for (i=0; i<6; i++)
put_count32(data->cnt32var[i],iobuf);
for (i=0; i<6; i++)
put_count(data->cntzvar[i],iobuf);
for (i=0; i<8; i++)
put_count(data->cntvar[i],iobuf);
for (i=0; i<10; i++)
put_scount16(data->scnt16var[i],iobuf);
for (i=0; i<12; i++)
put_scount32(data->scnt32var[i],iobuf);
for (i=0; i<12; i++)
put_scount(data->scntzvar[i],iobuf);
for (i=0; i<14; i++)
put_scount(data->scntvar[i],iobuf);
put_string(data->str16var,iobuf);
put_long_string(data->str32var,iobuf);
put_var_string(data->strvvar,iobuf);
return(put_item_end(iobuf,&item_header));
}
DNSServiceErrorType DNSSD_API DNSServiceRegisterRecord
(
DNSServiceRef sdRef,
DNSRecordRef *RecordRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
const char *fullname,
uint16_t rrtype,
uint16_t rrclass,
uint16_t rdlen,
const void *rdata,
uint32_t ttl,
DNSServiceRegisterRecordReply callBack,
void *context
)
{
char *msg = NULL, *ptr;
size_t len;
ipc_msg_hdr *hdr = NULL;
DNSServiceRef tmp = NULL;
DNSRecordRef rref = NULL;
int f1 = (flags & kDNSServiceFlagsShared) != 0;
int f2 = (flags & kDNSServiceFlagsUnique) != 0;
if (f1 + f2 != 1) return kDNSServiceErr_BadParam;
if (!sdRef || sdRef->op != connection || sdRef->sockfd < 0)
return kDNSServiceErr_BadReference;
*RecordRef = NULL;
len = sizeof(DNSServiceFlags);
len += 2 * sizeof(uint32_t); // interfaceIndex, ttl
len += 3 * sizeof(uint16_t); // rrtype, rrclass, rdlen
len += strlen(fullname) + 1;
len += rdlen;
hdr = create_hdr(reg_record_request, &len, &ptr, 0);
if (!hdr) goto error;
msg = (char *)hdr;
put_flags(flags, &ptr);
put_long(interfaceIndex, &ptr);
put_string(fullname, &ptr);
put_short(rrtype, &ptr);
put_short(rrclass, &ptr);
put_short(rdlen, &ptr);
put_rdata(rdlen, rdata, &ptr);
put_long(ttl, &ptr);
rref = malloc(sizeof(_DNSRecordRef_t));
if (!rref) goto error;
rref->app_context = context;
rref->app_callback = callBack;
rref->record_index = sdRef->max_index++;
rref->sdr = sdRef;
*RecordRef = rref;
hdr->client_context.context = rref;
hdr->reg_index = rref->record_index;
return deliver_request(msg, sdRef, 0);
error:
if (rref) free(rref);
if (tmp) free(tmp);
if (hdr) free(hdr);
return kDNSServiceErr_Unknown;
}
