char *pack_record(dns_record_t *record, size_t *rlen)
{
size_t record_len = sizeof(dns_record_t);
char *buf = malloc(record_len);
char *start = buf;
if (record->use_compression) {
memcpy(buf, record->cptr, 2);
buf += 2;
} else {
size_t domain_rec_len;
char *domain = pack_label(record->label, &domain_rec_len);
memcpy(buf, domain, domain_rec_len);
buf += domain_rec_len;
}
buf = write_uint16(buf, &record->rtype, true);
buf = write_uint16(buf, &record->rclass, true);
buf = write_uint32(buf, &record->ttl, true);
buf = write_uint16(buf, &record->rdlength, true);
memcpy(buf, record->rdata, record->rdlength);
buf += record->rdlength;
*rlen = buf - start;
#ifdef DEBUG
puts("output record");
dump_buffer(start, *rlen);
#endif
return start;
}
void
Squeezer_file_header_t::write_to_file(FILE * out) const
{
write_uint8(out, file_type_mark[0]);
write_uint8(out, file_type_mark[1]);
write_uint8(out, file_type_mark[2]);
write_uint8(out, file_type_mark[3]);
write_double(out, floating_point_check);
write_uint16(out, date_year);
write_uint8(out, date_month);
write_uint8(out, date_day);
write_uint8(out, time_hour);
write_uint8(out, time_minute);
write_uint8(out, time_second);
write_uint8(out, radiometer.horn);
write_uint8(out, radiometer.arm);
write_uint16(out, od);
write_double(out, first_obt);
write_double(out, last_obt);
write_double(out, first_scet_in_ms);
write_double(out, last_scet_in_ms);
write_uint32(out, number_of_chunks);
}
static int msp_send_packet(struct msp_sock *sock, struct msp_packet *packet)
{
assert(sock->header.remote.port);
if (daemon_addr.addrlen == 0){
if (make_local_sockaddr(&daemon_addr, "mdp.2.socket") == -1)
return -1;
}
uint8_t msp_header[5];
msp_header[0]=packet->flags;
// only set the ack flag if we've received a sequenced packet
if (sock->state & MSP_STATE_RECEIVED_DATA)
msp_header[0]|=FLAG_ACK;
write_uint16(&msp_header[1], sock->rx.next_seq);
write_uint16(&msp_header[3], packet->seq);
sock->previous_ack = sock->rx.next_seq;
struct fragmented_data data={
.fragment_count=3,
.iov={
{
.iov_base = (void*)&sock->header,
.iov_len = sizeof(struct mdp_header)
},
{
.iov_base = &msp_header,
.iov_len = sizeof(msp_header)
},
{
.iov_base = (void*)packet->payload,
static bool generate_output()
{
size_t n;
uint16_t C, A;
/* Write header */
write_data(MAGIC_STR, MAGIC_LEN);
/* Generate instructions */
C = A = 0;
for (n = 0; n < last_num_blocks; ++n)
{
if (last_blocks[n].is == NULL)
{
/* Check to see if we must start a new instruction */
if ( (C > 0 && last_blocks[n].offset !=
last_blocks[n - 1].offset + BS ) ||
(C == 0x7fffu) || (A > 0) )
{
emit_instruction(n, C, A);
C = A = 0;
}
++C;
}
else
{
if (A == 0x7fffu)
{
emit_instruction(n, C, A);
C = A = 0;
}
++A;
}
}
/* Emit final instruction (if necessary) */
if (C > 0 || A > 0) emit_instruction(last_num_blocks, C, A);
/* Write end-of-instructions */
write_uint32(0xffffffffu);
write_uint16(0xffffu);
write_uint16(0xffffu);
/* Add last file digest */
write_data(last_digest, DS);
/* Add first file digest (if known) */
if (!orig_digest_known)
{
fprintf(stderr, "WARNING: original file digest unknown; "
"generating version 1.0 differences file.\n");
}
else
{
write_data(orig_digest, DS);
}
return true;
}
static uint8_t* write_data_item(uint8_t* msg, uint16_t type, uint16_t length)
{
/* Octet 0 and 1 are the type code */
uint8_t* p = write_uint16(type,msg);
/* Octet 2 and 3 are the length, this excludes the header length (4) */
return write_uint16(length,p);
}
static uint8_t* write_message_header(uint8_t* msg, uint16_t msg_type)
{
/* Octet 0 and 1 are the message type */
uint8_t* p = write_uint16(msg_type,msg);
/* Octet 2 and 3 are the message length, set to 0 initially */
return write_uint16(0,p);
}
int opus_header_to_packet(const OpusHeader *h, unsigned char *packet, int len)
{
int i;
Packet p;
unsigned char ch;
p.data = packet;
p.maxlen = len;
p.pos = 0;
if (len<19)return 0;
if (!write_chars(&p, (const unsigned char*)"OpusHead", 8))
return 0;
/* Version is 1 */
ch = 1;
if (!write_chars(&p, &ch, 1))
return 0;
ch = h->channels;
if (!write_chars(&p, &ch, 1))
return 0;
if (!write_uint16(&p, h->preskip))
return 0;
if (!write_uint32(&p, h->input_sample_rate))
return 0;
if (!write_uint16(&p, h->gain))
return 0;
ch = h->channel_mapping;
if (!write_chars(&p, &ch, 1))
return 0;
if (h->channel_mapping != 0)
{
ch = h->nb_streams;
if (!write_chars(&p, &ch, 1))
return 0;
ch = h->nb_coupled;
if (!write_chars(&p, &ch, 1))
return 0;
/* Multi-stream support */
for (i=0;i<h->channels;i++)
{
if (!write_chars(&p, &h->stream_map[i], 1))
return 0;
}
}
return p.pos;
}
static int
write_header_v1(struct save_data *save_data,
struct ipset_node_cache *cache, ipset_node_id root)
{
/* Output the magic number for an IP set, and the file format
* version that we're going to write. */
rii_check(cork_stream_consumer_data(save_data->stream, NULL, 0, true));
rii_check(write_string(save_data->stream, MAGIC_NUMBER));
rii_check(write_uint16(save_data->stream, 0x0001));
/* Determine how many reachable nodes there are, to calculate the
* size of the set. */
size_t nonterminal_count = ipset_node_reachable_count(cache, root);
size_t set_size =
MAGIC_NUMBER_LENGTH + /* magic number */
sizeof(uint16_t) + /* version number */
sizeof(uint64_t) + /* length of set */
sizeof(uint32_t) + /* number of nonterminals */
(nonterminal_count * /* for each nonterminal: */
(sizeof(uint8_t) + /* variable number */
sizeof(uint32_t) + /* low pointer */
sizeof(uint32_t) /* high pointer */
));
/* If the root is a terminal, we need to add 4 bytes to the set
* size, for storing the terminal value. */
if (ipset_node_get_type(root) == IPSET_TERMINAL_NODE) {
set_size += sizeof(uint32_t);
}
rii_check(write_uint64(save_data->stream, set_size));
rii_check(write_uint32(save_data->stream, nonterminal_count));
return 0;
}
static void send_destination_down_resp(int s, const uint8_t* mac, enum dlep_status_code sc)
{
uint8_t msg[30];
uint16_t msg_len = 0;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_DEST_DOWN_RESP);
/* Write out our MAC Address */
p = write_data_item(p,DLEP_MAC_ADDRESS_DATA_ITEM,6);
memcpy(p,mac,6);
p += 6;
/* Write out our Status code */
p = write_status_code(p,sc);
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Destination Down Response message\n");
if (send(s,msg,msg_len,0) != msg_len)
printf("Failed to send Destination Down Response message: %s\n",strerror(errno));
}
static void jl_serialize_fptr(ios_t *s, void *fptr)
{
void **pbp = ptrhash_bp(&fptr_to_id, fptr);
if (*pbp == HT_NOTFOUND)
jl_error("unknown function pointer");
write_uint16(s, *(ptrint_t*)pbp);
}
static void test_compress(
FILE* outFp,
FILE* inpFp,
size_t messageMaxBytes,
size_t ringBufferBytes)
{
LZ4_stream_t* const lz4Stream = LZ4_createStream();
const size_t cmpBufBytes = LZ4_COMPRESSBOUND(messageMaxBytes);
char* const cmpBuf = (char*) malloc(cmpBufBytes);
char* const inpBuf = (char*) malloc(ringBufferBytes);
int inpOffset = 0;
for ( ; ; )
{
char* const inpPtr = &inpBuf[inpOffset];
#if 0
// Read random length data to the ring buffer.
const int randomLength = (rand() % messageMaxBytes) + 1;
const int inpBytes = (int) read_bin(inpFp, inpPtr, randomLength);
if (0 == inpBytes) break;
#else
// Read line to the ring buffer.
int inpBytes = 0;
if (!fgets(inpPtr, (int) messageMaxBytes, inpFp))
break;
inpBytes = (int) strlen(inpPtr);
#endif
{
const int cmpBytes = LZ4_compress_fast_continue(
lz4Stream, inpPtr, cmpBuf, inpBytes, cmpBufBytes, 1);
if (cmpBytes <= 0) break;
write_uint16(outFp, (uint16_t) cmpBytes);
write_bin(outFp, cmpBuf, cmpBytes);
// Add and wraparound the ringbuffer offset
inpOffset += inpBytes;
if ((size_t)inpOffset >= ringBufferBytes - messageMaxBytes) inpOffset = 0;
}
}
write_uint16(outFp, 0);
free(inpBuf);
free(cmpBuf);
LZ4_freeStream(lz4Stream);
}
//---------------------------------------------------------------------------------------------
void BitMessage::write_netaddr(const os::NetAddress addr)
{
uint8_t* ptr;
ptr = get_byte_space(4);
memcpy(ptr, addr.m_address, 4);
write_uint16(addr.port());
}
void write_uint16_n(const char *id, uint16_t* buf, int buf_len)
{
int i;
for(i = 0; i < buf_len; i++)
{
write_uint16((char*) id,buf[i]);
}
}
void *spice_marshaller_add_uint16(SpiceMarshaller *m, uint16_t v)
{
uint8_t *ptr;
ptr = spice_marshaller_reserve_space(m, sizeof(uint16_t));
write_uint16(ptr, v);
return (void *)ptr;
}
char *pack_question(dns_question_t *question, size_t *len)
{
size_t question_len = sizeof(dns_question_t);
char *buf = malloc(question_len);
char *start = buf;
size_t domain_rec_len;
char *domain = pack_label(question->label, &domain_rec_len);
memcpy(buf, domain, domain_rec_len);
buf += domain_rec_len;
buf = write_uint16(buf, &question->qtype, true);
buf = write_uint16(buf, &question->qclass, true);
*len = buf - start;
return start;
}
void gain_menu_branch(uint8_t com_type){
switch(com_type){
case DISPLAY:
uart0_printf("P: %f, I: %f, D: %f\r\n", c_gain->p_gain, c_gain->i_gain, c_gain->d_gain);
break;
case SET_P:
uart0_printf("P Gain is %f, input new value.\r\n", c_gain->p_gain);
c_gain->p_gain = uart0_get_float_input();
break;
case SET_I:
uart0_printf("I Gain is %f, input new value.\r\n", c_gain->i_gain);
c_gain->i_gain = uart0_get_float_input();
break;
case SET_D:
uart0_printf("D Gain is %f, input new value.\r\n", c_gain->d_gain);
c_gain->d_gain = uart0_get_float_input();
break;
case SET_Q_TH:
uart0_printf("OF quality threshold is %d, input new value. (range: 0~255)\r\n", c_flow->qual_th);
c_flow->qual_th = (uint16_t)uart0_get_float_input();
if(c_flow->qual_th > 255) c_flow->qual_th = 255;
break;
case SAVE:
write_float(P_ADD, c_gain->p_gain);
write_float(I_ADD, c_gain->i_gain);
write_float(D_ADD, c_gain->d_gain);
write_uint16(Q_TH_ADD, c_flow->qual_th);
uart0_printf("Saved!\r\n");
break;
case RESTORE:
c_gain->p_gain = read_float(P_ADD);
c_gain->i_gain = read_float(I_ADD);
c_gain->d_gain = read_float(D_ADD);
uart0_printf("Restore Parameters.\r\n");
break;
case EXIT:
menu_flg = 0;
input_detect = 0;
top_menu();
break;
default:
uart0_printf("invalid command\r\n");
input_detect = 0;
break;
}
}
int main(int argc, char* argv[])
{
FILE* ofile1;
FILE* ofile2;
char ostr[17];
uint16_t N[ORDER];
#ifdef SW
init_pipe_handler();
PTHREAD_DECL(gcd_daemon);
PTHREAD_CREATE(gcd_daemon);
#endif
ofile1 = fopen("gcd_inputs.txt","w");
ofile2 = fopen("gcd_result.txt","w");
int err = 0;
uint16_t S = 1;
if(argc > 1)
S = atoi(argv[1]);
fprintf(stderr,"Scale-factor = %d.\n",S);
srand48(19);
uint16_t i;
for(i = 0; i < ORDER; i++)
{
N[i] = ((uint16_t) (0x0fff * drand48())) * S;
fprintf(stderr,"N[%d] = %d\n", i, N[i]);
write_uint16("in_data",N[i]);
to_string(ostr,N[i]);
fprintf(ofile1,"%s\n", ostr);
}
uint16_t g = read_uint16("out_data");
fprintf(stderr,"GCD = %d.\n",g);
to_string(ostr,g);
fprintf(ofile2,"%s\n",ostr);
uint32_t et = read_uint32("elapsed_time");
fprintf(stderr,"Elapsed time = %u.\n", et);
fclose(ofile1);
fclose(ofile2);
#ifdef SW
PTHREAD_CANCEL(gcd_daemon);
close_pipe_handler();
#endif
return(0);
}
static int writer_uint16(lua_State* L)
{
writer_t* writer = lua_touserdata(L, 1);
lua_Integer integer = luaL_checkinteger(L, 2);
if(integer < 0 || integer > UINT16_MAX)
luaL_error(L, "unsigned overflow");
write_uint16(writer, (uint16_t)integer);
return 0;
}
static void do_llen(const char* line, uint8_t len)
{
if (len) goto on_error;
write_ok();
write_uint16(LINE_MAX_SIZE);
return ;
on_error:
write_ko();
return ;
}
int key_value_write_lines(FILE *f, struct key_value_specification *kvs, void *base_address[])
{
struct key_value_specification *k;
int rc;
int errs = 0;
for (k = kvs; k->key; k++) {
switch (k->type) {
case KVS_STRING:
rc = write_string(f, k, base_address);
break;
case KVS_INT64:
rc = write_int64(f, k, base_address);
break;
case KVS_INT32:
rc = write_int32(f, k, base_address);
break;
case KVS_INT16:
rc = write_int16(f, k, base_address);
break;
case KVS_INT8:
rc = write_int8(f, k, base_address);
break;
case KVS_UINT64:
rc = write_uint64(f, k, base_address);
break;
case KVS_UINT32:
rc = write_uint32(f, k, base_address);
break;
case KVS_UINT16:
rc = write_uint16(f, k, base_address);
break;
case KVS_UINT8:
rc = write_uint8(f, k, base_address);
break;
case KVS_DOUBLE:
rc = write_double(f, k, base_address);
break;
case KVS_FLOAT:
rc = write_float(f, k, base_address);
break;
default:
fprintf(stderr, "%s:%d: unknown key type '%c' for key '%s'\n",
__func__, __LINE__, k->type, k->key);
rc = -1;
break;
}
if (rc)
errs++;
}
return errs;
}
/* Emits an instruction to generate the last (C+A) blocks before position n. */
static void emit_instruction(size_t n, uint16_t C, uint16_t A)
{
uint8_t block[BS];
size_t a;
InputStream *is;
assert(C + A <= n && n <= last_num_blocks);
/* Write instruction */
write_uint32((C == 0) ? 0xffffffffu : last_blocks[n - A - C].offset/BS);
write_uint16(C);
write_uint16(A);
/* Add instruction data */
for (a = 0; a < A; ++a)
{
is = last_blocks[n - A + a].is;
is->seek(is, last_blocks[n - A + a].offset);
read_data(is, block, BS);
write_data(block, BS);
}
}
void _stlink_usb_write_mem8(stlink_t *sl, uint32_t addr, uint16_t len) {
struct stlink_libusb * const slu = sl->backend_data;
unsigned char* const data = sl->q_buf;
unsigned char* const cmd = sl->c_buf;
int i = fill_command(sl, SG_DXFER_TO_DEV, 0);
cmd[i++] = STLINK_DEBUG_COMMAND;
cmd[i++] = STLINK_DEBUG_WRITEMEM_8BIT;
write_uint32(&cmd[i], addr);
write_uint16(&cmd[i + 4], len);
send_only(slu, 0, cmd, slu->cmd_len);
send_only(slu, 1, data, len);
}
static void jl_serialize_tag_type(ios_t *s, jl_value_t *v)
{
if (jl_is_struct_type(v)) {
writetag(s, (jl_value_t*)jl_struct_kind);
jl_serialize_value(s, jl_struct_kind);
write_uint16(s, jl_tuple_len(((jl_struct_type_t*)v)->names));
write_int32(s, ((jl_struct_type_t*)v)->uid);
write_int32(s, ((jl_struct_type_t*)v)->size);
write_int32(s, ((jl_struct_type_t*)v)->alignment);
size_t nf = jl_tuple_len(((jl_struct_type_t*)v)->names);
ios_write(s, (char*)&((jl_struct_type_t*)v)->fields[0], nf*sizeof(jl_fielddesc_t));
jl_serialize_value(s, ((jl_struct_type_t*)v)->name);
jl_serialize_value(s, ((jl_struct_type_t*)v)->parameters);
jl_serialize_value(s, ((jl_struct_type_t*)v)->super);
jl_serialize_value(s, ((jl_struct_type_t*)v)->names);
jl_serialize_value(s, ((jl_struct_type_t*)v)->types);
jl_serialize_value(s, ((jl_struct_type_t*)v)->ctor_factory);
jl_serialize_value(s, ((jl_struct_type_t*)v)->env);
jl_serialize_value(s, ((jl_struct_type_t*)v)->linfo);
jl_serialize_fptr(s, ((jl_struct_type_t*)v)->fptr);
}
else if (jl_is_bits_type(v)) {
writetag(s, jl_struct_kind);
jl_serialize_value(s, jl_bits_kind);
if (v == (jl_value_t*)jl_int32_type)
write_uint8(s, 2);
else if (v == (jl_value_t*)jl_bool_type)
write_uint8(s, 3);
else if (v == (jl_value_t*)jl_int64_type)
write_uint8(s, 4);
else
write_uint8(s, 0);
jl_serialize_value(s, ((jl_tag_type_t*)v)->name);
jl_serialize_value(s, ((jl_bits_type_t*)v)->parameters);
write_int32(s, ((jl_bits_type_t*)v)->nbits);
jl_serialize_value(s, ((jl_bits_type_t*)v)->super);
write_int32(s, ((jl_bits_type_t*)v)->uid);
}
else {
assert(jl_is_tag_type(v));
writetag(s, jl_tag_kind);
jl_serialize_value(s, ((jl_tag_type_t*)v)->name);
jl_serialize_value(s, ((jl_tag_type_t*)v)->parameters);
jl_serialize_value(s, ((jl_tag_type_t*)v)->super);
}
}
int test_enc () {
char buf[1024];
char *buf_ptr = (char *) &buf;
char *res_enc = NULL;
char *res_dec = NULL;
uint8_t v8;
res_enc = write_uint8(buf_ptr, 42);
res_dec = read_uint8(buf_ptr, &v8);
assert(buf_ptr - res_dec == buf_ptr - res_enc);
assert(v8 == 42);
uint16_t v16;
res_enc = write_uint16(buf_ptr, 4200);
res_dec = read_uint16(buf_ptr, &v16);
assert(buf_ptr - res_dec == buf_ptr - res_enc);
assert(v16 == 4200);
uint32_t v32;
res_enc = write_uint32(buf_ptr, 420000);
res_dec = read_uint32(buf_ptr, &v32);
assert(buf_ptr - res_dec == buf_ptr - res_enc);
assert(v32 == 420000);
int32_t i32;
res_enc = write_int32(buf_ptr, -420000);
res_dec = read_int32(buf_ptr, &i32);
assert(buf_ptr - res_dec == buf_ptr - res_enc);
assert(i32 == -420000);
char* str = "hello world";
uint16_t str_len;
res_enc = write_string(buf_ptr, str, strlen(str));
res_dec = read_string(buf_ptr, &str, &str_len);
assert(buf_ptr - res_dec == buf_ptr - res_enc);
assert(!strcmp(str, "hello world"));
assert(strlen(str) == str_len);
char *tmp = "1234512345";
res_enc = write_buffer(buf_ptr, tmp, 10);
assert(res_enc - buf_ptr == 10);
for (int i = 0; i < 10; i++) assert(*(buf + i) == *(tmp + i));
return 0;
}
static void send_heartbeat(int s, uint16_t router_heartbeat_interval)
{
uint8_t msg[30];
uint16_t msg_len = 0;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_PEER_HEARTBEAT);
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Heartbeat message\n");
if (send(s,msg,msg_len,0) != msg_len)
printf("Failed to send Heartbeat message: %s\n",strerror(errno));
}
static int send_session_init_message(int s, uint32_t router_heartbeat_interval)
{
uint8_t msg[300];
uint16_t msg_len = 0;
size_t peer_type_len = 0;
uint8_t flags = 0x00;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_SESSION_INIT);
/* Write out our Heartbeat Interval */
p = write_data_item(p,DLEP_HEARTBEAT_INTERVAL_DATA_ITEM,4);
p = write_uint32(router_heartbeat_interval,p);
/* Write out Peer Type */
peer_type_len = strlen(PEER_TYPE);
if (peer_type_len > sizeof(msg) - 17)
peer_type_len = sizeof(msg) - 17;
p = write_data_item(p,DLEP_PEER_TYPE_DATA_ITEM, 1 + peer_type_len); /* includes length of the flag + description fields */
*p++ = flags;
if (peer_type_len)
{
memcpy(p, PEER_TYPE, peer_type_len);
p += peer_type_len;
}
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Session Initialization message\n");
if (send(s,msg,msg_len,0) != msg_len)
{
printf("Failed to send Session Initialization message: %s\n",strerror(errno));
return 0;
}
return 1;
}
void _stlink_usb_read_mem32(stlink_t *sl, uint32_t addr, uint16_t len) {
struct stlink_libusb * const slu = sl->backend_data;
unsigned char* const data = sl->q_buf;
unsigned char* const cmd = sl->c_buf;
ssize_t size;
int i = fill_command(sl, SG_DXFER_FROM_DEV, len);
cmd[i++] = STLINK_DEBUG_COMMAND;
cmd[i++] = STLINK_DEBUG_READMEM_32BIT;
write_uint32(&cmd[i], addr);
write_uint16(&cmd[i + 4], len);
size = send_recv(slu, 1, cmd, slu->cmd_len, data, len);
if (size == -1) {
printf("[!] send_recv\n");
return;
}
sl->q_len = (size_t) size;
stlink_print_data(sl);
}
static int send_session_term_resp(int s)
{
uint8_t msg[30];
uint16_t msg_len = 0;
/* Write the message header */
uint8_t* p = write_message_header(msg,DLEP_SESSION_TERM_RESP);
msg_len = p - msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,msg + 2);
printf("Sending Session Termination Response message\n");
if (send(s,msg,msg_len,0) != msg_len)
{
printf("Failed to send Session Termination Response message: %s\n",strerror(errno));
return -1;
}
return 0;
}
static int send_session_term(int s, enum dlep_status_code sc, uint8_t** msg, uint32_t modem_heartbeat_interval)
{
uint16_t msg_len = 0;
uint8_t* p;
/* Make sure we have room for the header */
uint8_t* new_msg = realloc(*msg,9);
if (!new_msg)
{
printf("Failed to allocate message buffer");
return -1;
}
*msg = new_msg;
/* Write the message header */
p = write_message_header(*msg,DLEP_SESSION_TERM);
/* Write out our Status Code */
p = write_status_code(p,sc);
msg_len = p - *msg;
/* Octet 2 and 3 are the message length, minus the length of the header */
write_uint16(msg_len - 4,*msg + 2);
printf("Sending Session Termination message\n");
if (send(s,*msg,msg_len,0) != msg_len)
{
printf("Failed to send Session Termination message: %s\n",strerror(errno));
return -1;
}
/* Now enter the Session termination state */
return term_session(s,msg,modem_heartbeat_interval);
}
char *pack_header(dns_header_t *header)
{
size_t header_len = sizeof(dns_header_t);
char *buf = malloc(header_len);
char *start = buf;
buf = write_uint16(buf, &header->id, true);
buf = write_uint16(buf, (unsigned short *)&header->flags, true);
buf = write_uint16(buf, &header->qdcount, true);
buf = write_uint16(buf, &header->ancount, true);
buf = write_uint16(buf, &header->nscount, true);
buf = write_uint16(buf, &header->arcount, true);
#ifdef DEBUG
puts("output header");
dump_buffer(start, header_len);
#endif
return start;
}
