static void
send_data(const ip_addr_t *addr, u16_t port)
{
u16_t *payload;
int ret;
if (tftp_state.last_data != NULL) {
pbuf_free(tftp_state.last_data);
}
tftp_state.last_data = init_packet(TFTP_DATA, tftp_state.blknum, TFTP_MAX_PAYLOAD_SIZE);
if (tftp_state.last_data == NULL) {
return;
}
payload = (u16_t *) tftp_state.last_data->payload;
ret = tftp_state.ctx->read(tftp_state.handle, &payload[2], TFTP_MAX_PAYLOAD_SIZE);
if (ret < 0) {
send_error(addr, port, TFTP_ERROR_ACCESS_VIOLATION, "Error occured while reading the file.");
close_handle();
return;
}
pbuf_realloc(tftp_state.last_data, (u16_t)(TFTP_HEADER_LENGTH + ret));
resend_data(addr, port);
}
int sendACK(struct dhcpMessage *oldpacket, u_int32_t yiaddr)
{
struct dhcpMessage packet;
struct option_set *curr;
unsigned char *lease_time;
//Foxconn added start Bob Guo 11/15/2006
FILE *fp;
unsigned char *client_mac, *client_ip;
char logBuffer[96];
//Foxconn added end Bob Guo 11/15/2006
u_int32_t lease_time_align = server_config.lease;
struct in_addr addr;
init_packet(&packet, oldpacket, DHCPACK);
packet.yiaddr = yiaddr;
if ((lease_time = get_option(oldpacket, DHCP_LEASE_TIME))) {
memcpy(&lease_time_align, lease_time, 4);
lease_time_align = ntohl(lease_time_align);
if (lease_time_align > server_config.lease)
lease_time_align = server_config.lease;
else if (lease_time_align < server_config.min_lease)
lease_time_align = server_config.lease;
}
add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
curr = server_config.options;
while (curr) {
if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
add_option_string(packet.options, curr->data);
curr = curr->next;
}
add_bootp_options(&packet);
addr.s_addr = packet.yiaddr;
LOG(LOG_INFO, "sending ACK to %s", inet_ntoa(addr));
if (send_packet(&packet, 0) < 0)
return -1;
add_lease(packet.chaddr, packet.yiaddr, lease_time_align);
//Foxconn added start Bob Guo 11/15/2006
client_mac = (unsigned char *)packet.chaddr;
client_ip = (unsigned char *)&packet.yiaddr;
sprintf(logBuffer, "[DHCP IP: (%d.%d.%d.%d)] to MAC address %02X:%02X:%02X:%02X:%02X:%02X,",
*client_ip, *(client_ip+1), *(client_ip+2), *(client_ip+3),
*client_mac, *(client_mac+1), *(client_mac+2), *(client_mac+3), *(client_mac+4), *(client_mac+5));
if ((fp = fopen("/dev/aglog", "r+")) != NULL)
{
fwrite(logBuffer, sizeof(char), strlen(logBuffer)+1, fp);
fclose(fp);
}
//Foxconn added end Bob Guo 11/15/2006
return 0;
}
static
void send_data()
{
int data_size = 0;
static unsigned temperature;
temperature = 21;
clear_buffer(outputBuffer);
clear_buffer(payload_buf);
generate_payload(payload_buf,temperature);
if(init_buffer(COAP_DATA_BUFF_SIZE)){
coap_packet_t* request =\
(coap_packet_t*)allocate_buffer(sizeof(coap_packet_t));
init_packet(request);
coap_set_method(request, COAP_POST);
request->tid = xact_id++;
request->type = MESSAGE_TYPE_CON;
coap_set_header_uri(request,service_uri);
coap_set_option(request, Option_Type_Uri_Host,
sizeof(char)*strlen(server_ip), (uint8_t*)server_ip);
coap_set_option(request, Option_Type_Proxy_Uri,
sizeof(char)*strlen(proxy_uri), (uint8_t*)proxy_uri);
coap_set_payload(request,(uint8_t*)payload_buf,
sizeof(char)*strlen(payload_buf));
data_size = serialize_packet(request, (uint8_t*)outputBuffer);
PRINTF("Now sending request to base station [");
PRINTF(&client_conn->ripaddr);
PRINTF("]:%u/%s\n",REMOTE_PORT,service_uri);
uip_udp_packet_send(client_conn, outputBuffer, data_size);
delete_buffer();
}
}
static void send_ACK(GDHCPServer *dhcp_server,
struct dhcp_packet *client_packet, uint32_t dest)
{
struct dhcp_packet packet;
uint32_t lease_time_sec;
struct in_addr addr;
init_packet(dhcp_server, &packet, client_packet, DHCPACK);
packet.yiaddr = htonl(dest);
lease_time_sec = dhcp_server->lease_seconds;
dhcp_add_option_uint32(&packet, DHCP_LEASE_TIME, lease_time_sec);
add_server_options(dhcp_server, &packet);
addr.s_addr = htonl(dest);
debug(dhcp_server, "Sending ACK to %s", inet_ntoa(addr));
send_packet_to_client(dhcp_server, &packet);
add_lease(dhcp_server, 0, packet.chaddr, packet.yiaddr);
if (dhcp_server->event_fn)
dhcp_server->event_fn(ether_ntoa((void*)packet.chaddr),
inet_ntoa(addr),
dhcp_server->fn_data);
}
void init_multicast_packet(struct multicast_packet *mp,
enum packet_flags flags, uint8_t hops, const rimeaddr_t *originator,
const rimeaddr_t *sender, uint8_t seqno, uint8_t num_ids) {
init_packet((struct packet*)mp, MULTICAST|flags, hops, originator, sender, seqno);
mp->num_ids = num_ids;
}
/**
* Streams a message instead of getting the entire msg as a byte array
* and then sending the bytes accross.
*/
void stream_msg(ScripterMsg* msg) {
init_packet();
// send header
put_slip_char(get_msg_id_most_repr(msg->id));
put_slip_char(get_msg_id_least_repr(msg->id));
put_slip_char(msg->param_count);
// send parameters
MsgParam* param = msg->parameters;
while(param != NULL) {
// size is 3 bytes, so we first get
// rid of most representative byte
if (param->type == PT_BYTE_STREAM) {
int size = (*(param->data.data_stream.fp_get_size))(¶m->data.data_stream);
put_slip_char(get_size_most_repr(size));
put_slip_char(get_size_middle_repr(size));
put_slip_char(get_size_least_repr(size));
char *c = NULL;
while( (c =(*(param->data.data_stream.fp_get_char))(¶m->data.data_stream)) != NULL ) {
put_slip_char(*c);
}
} else {
put_slip_char(get_size_most_repr(param->data.data_blob.size));
put_slip_char(get_size_middle_repr(param->data.data_blob.size));
put_slip_char(get_size_least_repr(param->data.data_blob.size));
int i;
for(i=0; i<(int)param->data.data_blob.size; i++) {
put_slip_char(*(param->data.data_blob.data+i));
}
}
param = param->next_param;
}
finish_packet();
}
static void
send_data(void)
{
char buf[MAX_PAYLOAD_LEN];
if (init_buffer(COAP_DATA_BUFF_SIZE)) {
int data_size = 0;
int service_id = random_rand() % NUMBER_OF_URLS;
coap_packet_t* request = (coap_packet_t*)allocate_buffer(sizeof(coap_packet_t));
init_packet(request);
coap_set_method(request, COAP_GET);
request->tid = xact_id++;
request->type = MESSAGE_TYPE_CON;
coap_set_header_uri(request, service_urls[service_id]);
data_size = serialize_packet(request, buf);
PRINTF("Client sending request to:[");
PRINT6ADDR(&client_conn->ripaddr);
PRINTF("]:%u/%s\n", (uint16_t)REMOTE_PORT, service_urls[service_id]);
uip_udp_packet_send(client_conn, buf, data_size);
delete_buffer();
}
}
void collect(socket_fd client_socket){
packet_t anything;
unsigned int usleep_time = (unsigned int) 1000000 / samples_per_second;
struct sockaddr_in* sock = alloc(struct sockaddr_in, 1);
char buffer[sizeof(packet_t)];
sock->sin_family = AF_INET;
sock->sin_port = htons(sink_dport);
sock->sin_addr.s_addr = inet_addr(sink_dip);
while(npackets > 0){
memset(&anything, 0, sizeof(anything));
init_packet(&anything);
write_data(anything.accumulated_time, anything.in_time, anything.id, "me", anything.samples);
swap_packet_byte_order(&anything);
memcpy(buffer, &anything, sizeof(packet_t));
if(sendto(client_socket, buffer, sizeof(packet_t), 0,(const struct sockaddr *) sock, sizeof(struct sockaddr_in)) == -1){
log(E, "Could not send packet\n");
}
npackets--;
usleep(usleep_time);
}
printf("Simulation has ended.\n");
}
/**
* Function called from within Lua to wipe the camscripter graphics area clean.
* Just forward on across the serial port.
*/
int clear_graphics(lua_State *_l) {
init_packet();
put_slip_char(get_msg_id_most_repr(CLEAR_GRAPHICS_MSG_ID));
put_slip_char(get_msg_id_least_repr(CLEAR_GRAPHICS_MSG_ID));
put_slip_char(0); // number of params
finish_packet();
return 0;
}
/*
* Write a pubkey-enc packet for the public key PK to OUT.
*/
int
write_pubkey_enc (ctrl_t ctrl,
PKT_public_key *pk, int throw_keyid, DEK *dek, iobuf_t out)
{
PACKET pkt;
PKT_pubkey_enc *enc;
int rc;
gcry_mpi_t frame;
print_pubkey_algo_note ( pk->pubkey_algo );
enc = xmalloc_clear ( sizeof *enc );
enc->pubkey_algo = pk->pubkey_algo;
keyid_from_pk( pk, enc->keyid );
enc->throw_keyid = throw_keyid;
/* Okay, what's going on: We have the session key somewhere in
* the structure DEK and want to encode this session key in an
* integer value of n bits. pubkey_nbits gives us the number of
* bits we have to use. We then encode the session key in some
* way and we get it back in the big intger value FRAME. Then
* we use FRAME, the public key PK->PKEY and the algorithm
* number PK->PUBKEY_ALGO and pass it to pubkey_encrypt which
* returns the encrypted value in the array ENC->DATA. This
* array has a size which depends on the used algorithm (e.g. 2
* for Elgamal). We don't need frame anymore because we have
* everything now in enc->data which is the passed to
* build_packet(). */
frame = encode_session_key (pk->pubkey_algo, dek,
pubkey_nbits (pk->pubkey_algo, pk->pkey));
rc = pk_encrypt (pk->pubkey_algo, enc->data, frame, pk, pk->pkey);
gcry_mpi_release (frame);
if (rc)
log_error ("pubkey_encrypt failed: %s\n", gpg_strerror (rc) );
else
{
if ( opt.verbose )
{
char *ustr = get_user_id_string_native (ctrl, enc->keyid);
log_info (_("%s/%s.%s encrypted for: \"%s\"\n"),
openpgp_pk_algo_name (enc->pubkey_algo),
openpgp_cipher_algo_name (dek->algo),
dek->use_aead? openpgp_aead_algo_name (dek->use_aead)
/**/ : "CFB",
ustr );
xfree (ustr);
}
/* And write it. */
init_packet (&pkt);
pkt.pkttype = PKT_PUBKEY_ENC;
pkt.pkt.pubkey_enc = enc;
rc = build_packet (out, &pkt);
if (rc)
log_error ("build_packet(pubkey_enc) failed: %s\n",
gpg_strerror (rc));
}
free_pubkey_enc(enc);
return rc;
}
int sendNAK(struct dhcpMessage *oldpacket)
{
struct dhcpMessage packet;
init_packet(&packet, oldpacket, DHCPNAK);
DEBUG(LOG_INFO, "sending NAK");
return send_packet(&packet, 1);
}
/* open a link */
void init_ethmac()
{
/* initialize the packet rx buffer */
init_packet();
/* open ethernet port and wait for connection requests
keep trying forever */
while (!open_link());
}
int FAST_FUNC send_NAK(struct dhcpMessage *oldpacket)
{
struct dhcpMessage packet;
init_packet(&packet, oldpacket, DHCPNAK);
DEBUG("Sending NAK");
return send_packet(&packet, 1);
}
/* NOINLINE: limit stack usage in caller */
static NOINLINE void send_NAK(struct dhcp_packet *oldpacket)
{
struct dhcp_packet packet;
init_packet(&packet, oldpacket, DHCPNAK);
log1("Sending NAK");
send_packet(&packet, /*force_bcast:*/ 1);
}
/****************
* Make a hash value from the public key certificate
*/
void
hash_public_key( MD_HANDLE md, PKT_public_key *pk )
{
PACKET pkt;
int rc = 0;
int ctb;
ulong pktlen;
int c;
IOBUF a = iobuf_temp();
#if 0
FILE *fp = fopen("dump.pk", "a");
int i=0;
fprintf(fp, "\nHashing PK (v%d):\n", pk->version);
#endif
/* build the packet */
init_packet(&pkt);
pkt.pkttype = PKT_PUBLIC_KEY;
pkt.pkt.public_key = pk;
if( (rc = build_packet( a, &pkt )) )
log_fatal("build public_key for hashing failed: %s\n", g10_errstr(rc));
if( !(pk->version == 3 && pk->pubkey_algo == 16) ) {
/* skip the constructed header but don't do this for our very old
* v3 ElG keys */
ctb = iobuf_get_noeof(a);
pktlen = 0;
if( (ctb & 0x40) ) {
c = iobuf_get_noeof(a);
if( c < 192 )
pktlen = c;
else if( c < 224 ) {
pktlen = (c - 192) * 256;
c = iobuf_get_noeof(a);
pktlen += c + 192;
}
else if( c == 255 ) {
pktlen = iobuf_get_noeof(a) << 24;
pktlen |= iobuf_get_noeof(a) << 16;
pktlen |= iobuf_get_noeof(a) << 8;
pktlen |= iobuf_get_noeof(a);
}
}
else {
int lenbytes = ((ctb&3)==3)? 0 : (1<<(ctb & 3));
for( ; lenbytes; lenbytes-- ) {
pktlen <<= 8;
pktlen |= iobuf_get_noeof(a);
}
}
/* hash a header */
md_putc( md, 0x99 );
pktlen &= 0xffff; /* can't handle longer packets */
md_putc( md, pktlen >> 8 );
md_putc( md, pktlen & 0xff );
}
static void send_inform(GDHCPServer *dhcp_server,
struct dhcp_packet *client_packet)
{
struct dhcp_packet packet;
init_packet(dhcp_server, &packet, client_packet, DHCPACK);
add_server_options(dhcp_server, &packet);
send_packet_to_client(dhcp_server, &packet);
}
int parse_gesture(const unsigned char *raw) {
Packet *p = init_packet(raw);
printf("%s\n", get_gesture(p));
destroy_packet(p);
return 0;
}
int init_pongpacket(struct mt_packet *packet, unsigned char *srcmac, unsigned char *dstmac) {
init_packet(packet, MT_PTYPE_PONG, srcmac, dstmac, 0, 0);
/* Zero out sessionkey & counter */
bzero(packet->data + 14, 4);
/* Remove data counter field from header */
packet->size -= 4;
return packet->size;
}
static void
write_header( cipher_filter_context_t *cfx, IOBUF a )
{
PACKET pkt;
PKT_encrypted ed;
byte temp[18];
unsigned blocksize;
unsigned nprefix;
blocksize = cipher_get_blocksize( cfx->dek->algo );
if( blocksize < 8 || blocksize > 16 )
log_fatal("unsupported blocksize %u\n", blocksize );
memset( &ed, 0, sizeof ed );
ed.len = cfx->datalen;
ed.extralen = blocksize+2;
ed.new_ctb = !ed.len && !RFC1991;
if( cfx->dek->use_mdc ) {
ed.mdc_method = DIGEST_ALGO_SHA1;
cfx->mdc_hash = md_open( DIGEST_ALGO_SHA1, 0 );
if ( DBG_HASHING )
md_start_debug( cfx->mdc_hash, "creatmdc" );
}
{
char buf[20];
sprintf (buf, "%d %d", ed.mdc_method, cfx->dek->algo);
write_status_text (STATUS_BEGIN_ENCRYPTION, buf);
}
init_packet( &pkt );
pkt.pkttype = cfx->dek->use_mdc? PKT_ENCRYPTED_MDC : PKT_ENCRYPTED;
pkt.pkt.encrypted = &ed;
if( build_packet( a, &pkt ))
log_bug("build_packet(ENCR_DATA) failed\n");
nprefix = blocksize;
randomize_buffer( temp, nprefix, 1 );
temp[nprefix] = temp[nprefix-2];
temp[nprefix+1] = temp[nprefix-1];
print_cipher_algo_note( cfx->dek->algo );
cfx->cipher_hd = cipher_open( cfx->dek->algo,
cfx->dek->use_mdc? CIPHER_MODE_CFB
: CIPHER_MODE_AUTO_CFB, 1 );
/* log_hexdump( "thekey", cfx->dek->key, cfx->dek->keylen );*/
cipher_setkey( cfx->cipher_hd, cfx->dek->key, cfx->dek->keylen );
cipher_setiv( cfx->cipher_hd, NULL, 0 );
/* log_hexdump( "prefix", temp, nprefix+2 ); */
if( cfx->mdc_hash ) /* hash the "IV" */
md_write( cfx->mdc_hash, temp, nprefix+2 );
cipher_encrypt( cfx->cipher_hd, temp, temp, nprefix+2);
cipher_sync( cfx->cipher_hd );
iobuf_write(a, temp, nprefix+2);
cfx->header=1;
}
int sendNAK(struct dhcpMessage *oldpacket)
{
struct dhcpMessage packet;
init_packet(&packet, oldpacket, DHCPNAK);
LOG(LOG_INFO, "broadcasting NAK to %02x:%02x:%02x:%02x:%02x:%02x",
packet.chaddr[0], packet.chaddr[1], packet.chaddr[2],
packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]);
return send_packet(&packet, 1);
}
/**
* Sends the picture currently in the pixbuf over serial
*/
int send_picture_msg(lua_State *_l) {
uint32_t x, y;
uint32_t size_x, size_y;
// only send if we're in debug mode
if (debug_on) {
init_packet();
// First the header
// first the ID we have to put it in two bytes
// big endian
put_slip_char(get_msg_id_most_repr(PPM_MSG_ID));
put_slip_char(get_msg_id_least_repr(PPM_MSG_ID));
// now the param count. 1 bytes
put_slip_char(1);
cc3_pixbuf_rewind(); // just in case
uint8_t *row = cc3_malloc_rows(1);
// now parameters
size_x = cc3_g_pixbuf_frame.width;
size_y = cc3_g_pixbuf_frame.height;
char* head = malloc(20);
sprintf(head,"P6\n%d %d\n255\n",size_x,size_y );
uint32_t size = strlen(head)+size_x*size_y*3;
// size is 3 bytes, so we first get
// rid of most representative byte
put_slip_char(get_size_most_repr(size));
put_slip_char(get_size_middle_repr(size));
put_slip_char(get_size_least_repr(size));
put_slip_string(head);
free(head);
bool led_on = false;
for (y = 0; y < size_y; y++) {
cc3_pixbuf_read_rows(row, 1);
cc3_led_set_state(0, led_on=!led_on);
for (x = 0; x < size_x * 3U; x++) {
/* Sleep to prevent byte-loss. Seems a bit extreme, but
I saw problems with even 1000 and 500 as intervals. */
if (x % 100 == 0) {
cc3_timer_wait_ms (5);
}
put_slip_char(row[x]);
}
}
cc3_led_set_state(0, false);
free(row);
finish_packet();
}
return 0;
}
int parse_packet(const unsigned char *raw) {
Packet *p = init_packet(raw);
printf("x=%f\ty=%f\tz=%f\tval=%f\n", p->acc_x, p->acc_y, p->acc_z, p->w);
printf("gesture=%s\narm=%s\n", get_gesture(p), get_arm(p));
destroy_packet(p);
return 0;
}
int sendACK(struct dhcpMessage *oldpacket, u_int32_t yiaddr)
{
struct dhcpMessage packet;
struct option_set *curr;
unsigned char *lease_time;
u_int32_t lease_time_align = server_config.lease;
struct in_addr addr;
init_packet(&packet, oldpacket, DHCPACK);
packet.yiaddr = yiaddr;
if ((lease_time = get_option(oldpacket, DHCP_LEASE_TIME))) {
memcpy(&lease_time_align, lease_time, 4);
lease_time_align = ntohl(lease_time_align);
if (lease_time_align > server_config.lease)
lease_time_align = server_config.lease;
else if (lease_time_align < server_config.min_lease)
lease_time_align = server_config.lease;
}
add_simple_option(packet.options, DHCP_LEASE_TIME, htonl(lease_time_align));
curr = server_config.options;
while (curr) {
if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
add_option_string(packet.options, curr->data);
curr = curr->next;
}
add_bootp_options(&packet);
addr.s_addr = packet.yiaddr;
// LOG(LOG_INFO, "sending ACK to %s", inet_ntoa(addr));
if(get_option(oldpacket, DHCP_SERVER_ID)){ // by honor
LOG(LOG_INFO, "broadcasting ACK of %s to %02x:%02x:%02x:%02x:%02x:%02x", inet_ntoa(addr),
packet.chaddr[0], packet.chaddr[1], packet.chaddr[2],
packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]);
if (send_packet(&packet, 1) < 0) return -1;
}
else{
LOG(LOG_INFO, "sending ACK of %s to %02x:%02x:%02x:%02x:%02x:%02x", inet_ntoa(addr),
packet.chaddr[0], packet.chaddr[1], packet.chaddr[2],
packet.chaddr[3], packet.chaddr[4], packet.chaddr[5]);
if (send_packet(&packet, 0) < 0) return -1;
}
add_lease(packet.chaddr, packet.yiaddr, lease_time_align);
return 0;
}
/**
* \brief Function to send SUBSCRIBE packet to broker.
* \param conn The connection to SUBSCRIBE on.
* \param topic The topic for which the message should be published.
* \param topic_len The length of the topic.
*/
umqtt_ret broker_subscribe(struct broker_conn *conn, const char *topic,
size_t topic_len) {
LOG_DEBUG_FN("fn: broker_subscribe");
umqtt_ret ret = UMQTT_SUCCESS;
/* send subscribe packet */
struct mqtt_packet *pkt = construct_default_packet(SUBSCRIBE, 0, 0);
if (!pkt) {
LOG_ERROR("Creating subscribe packet");
return UMQTT_PACKET_ERROR;
}
set_un_subscribe_payload(pkt, topic, topic_len, UMQTT_DEFAULT_QOS);
finalise_packet(pkt);
/* register subscription */
conn->subs[conn->sub_count] = pkt;
ret = conn->send_method(conn, pkt);
if (ret) {
LOG_ERROR("Broker connection failed");
free_packet(pkt);
return ret;
}
/* get response */
struct mqtt_packet *pkt_resp;
if (init_packet(&pkt_resp)) {
LOG_ERROR("Allocating memory");
return UMQTT_MEM_ERROR;
}
uint8_t count = 0;
do {
ret = conn->receive_method(conn, pkt_resp);
if (ret) {
LOG_ERROR("Subscribe Response Packet Failed");
free_packet(pkt_resp);
return ret;
}
} while (pkt_resp->fixed->generic.type != SUBACK && count++ < MAX_RESP_PKT_RETRIES);
if (pkt_resp->fixed->generic.type != SUBACK) {
ret = UMQTT_SUBSCRIBE_ERROR;
}
free_packet(pkt_resp);
return ret;
}
static usbd_status
open_out_jack(struct umidi_jack *jack, void *arg, void (*intr)(void *))
{
if (jack->opened)
return USBD_IN_USE;
jack->arg = arg;
jack->u.out.intr = intr;
init_packet(&jack->packet);
jack->opened = 1;
jack->endpoint->num_open++;
return USBD_NORMAL_COMPLETION;
}
static void send_NAK(GDHCPServer *dhcp_server,
struct dhcp_packet *client_packet)
{
struct dhcp_packet packet;
init_packet(dhcp_server, &packet, client_packet, DHCPNAK);
debug(dhcp_server, "Sending NAK");
dhcp_send_raw_packet(&packet,
dhcp_server->server_nip, SERVER_PORT,
INADDR_BROADCAST, CLIENT_PORT, MAC_BCAST_ADDR,
dhcp_server->ifindex);
}
/**
* \brief Function to test the encoding and decoding of the remaining packet
* length.
* \return sucess or failurer of tests.
*/
int test_enc_dec_remaining_pkt_len() {
int ret = 0, i, j;
unsigned int lengths[8] = { 0, 127, 128, 16383,
16384, 2097151, 2097152, 268435455 };
struct mqtt_packet *pkt = '\0';
log_std(LOG_INFO,
"Testing remaining packet length encoding/decoding and length estimation:");
init_packet(&pkt);
init_packet_fixed_header(pkt, CONNECT);
for (i = 0; i < 8; i++) {
encode_remaining_len(pkt, lengths[i]);
log_std(LOG_INFO, "Length: %d\t\tEncoded: %02X %02X %02X %02X\t",
lengths[i], pkt->fixed->remain_len[0],
pkt->fixed->remain_len[1],
pkt->fixed->remain_len[2],
pkt->fixed->remain_len[3]);
int len_dec = decode_remaining_len(pkt);
log_std(LOG_INFO, "Decoded:%d\t\t", len_dec);
if (len_dec != lengths[i]) {
log_std(LOG_INFO, "\tDecode FAILED\t");
ret = 1;
}
int bytes = required_remaining_len_bytes(lengths[i]);
for (j = 1; j <= 4 && (pkt->fixed->remain_len[j-1] & 0x80); j++);
log_std(LOG_INFO, "Estimated %d bytes %d ", bytes, j);
if (bytes == j) {
log_std(LOG_INFO, "Successfully");
} else {
log_std(LOG_INFO, "Unsuccessfully");
}
}
free_packet(pkt);
if (ret) {
log_std(LOG_INFO, "Remaining length encoding/decoding failed");
} else {
log_std(LOG_INFO, "Remaining length encoding/decoding successful");
}
return ret;
}
int main() {
struct packet p;
init_packet(&p);
print_packet(&p);
tag_client_send(&p);
print_packet(&p);
tag_server_recv(&p);
print_packet(&p);
tag_server_send(&p);
print_packet(&p);
tag_client_recv(&p);
print_packet(&p);
return 0;
}
int sendACK(struct dhcpMessage *oldpacket, u_int32_t yiaddr)
{
struct dhcpMessage packet;
struct option_set *curr;
char *lease_time;
u_int32_t lease_time_align = server_config.lease;
struct in_addr addr;
char *hostname;
char hostname_copy[64];
init_packet(&packet, oldpacket, DHCPACK);
packet.yiaddr = yiaddr;
if ((lease_time = get_option(oldpacket, DHCP_LEASE_TIME))) {
memcpy(&lease_time_align, lease_time, 4);
lease_time_align = ntohl(lease_time_align);
if (lease_time_align > server_config.lease)
lease_time_align = server_config.lease;
else if (lease_time_align < server_config.min_lease)
lease_time_align = server_config.lease;
}
add_simple_option(packet.options, DHCP_LEASE_TIME, lease_time_align);
curr = server_config.options;
while (curr) {
if (curr->data[OPT_CODE] != DHCP_LEASE_TIME)
add_option_string(packet.options, curr->data);
curr = curr->next;
}
add_bootp_options(&packet);
addr.s_addr = packet.yiaddr;
LOG(LOG_INFO, "sending ACK to %s", inet_ntoa(addr));
if (send_packet(&packet, 0) < 0)
return -1;
hostname = get_option(oldpacket, DHCP_HOST_NAME);
memset(hostname_copy, 0, sizeof(hostname_copy));
if (hostname) {
strncpy(hostname_copy, hostname, hostname[-1]);
}
add_lease(packet.chaddr, packet.yiaddr, lease_time_align, hostname_copy);
return 0;
}
void send_ack(pcap_t *p, struct pktbuf *inpkt, struct client_conf *client) {
struct pktbuf *pkt;
pkt = malloc(sizeof(struct pktbuf));
init_packet(pkt, inpkt, client);
pkt->dhcp_packet->xid = inpkt->dhcp_packet->xid;
build_options(pkt, DHCPACK, client);
fprintf(stderr, "\n\nWriting DHCPACK to socket: %d bytes\n\n", pkt->pktlen);
send_packet(p, pkt);
free(pkt);
}
