static int server_receive(int socket, struct server_data *data, int (*data_handler)(const char*,size_t,void*), void* data_handler_param) { size_t size; size = server_receive_size(socket, data); //VIR_DEBUG("expecting %lu bytes\n", size); //VIR_DEBUG("i_begin: %lu , available: %lu", data->i_begin, data->available); //Data size is bigger than what is available -> do multiple retrieval iterations while (data->available >= 0 && size > data->available) { if (data_handler(data->buf+data->i_begin, data->available, data_handler_param) < 0) { VIR_DEBUG("data handler error!\n"); return -1; } size -= data->available; //all available data has been consumed //Receive new data and reset i_begin if ((data->available = recv(socket, data->buf, SD_BUFSIZE, 0)) < 0) { VIR_DEBUG("error while recv'ing\n"); return -1; } data->i_begin = 0; } //available data is bigger than data size -> retrieve and update i_begin and available if (data_handler(data->buf+data->i_begin, size, data_handler_param) < 0) { VIR_DEBUG("data handler error!\n"); return -1; } data->i_begin += size; data->available -= size; return 0; }
/** * oseaclient_request_call_user_function: * @type: * @type: Type of oseaclient user space data: AFDAL_REQUEST_DATA, * AFDAL_REQUEST_SIMPLE_DATA, AFDAL_REQUEST_NUL_DATA * @handler: user space function to be executed * @user_data: user space data to be passed to @handler. * @oseaclient_data: afdal level data to be passed to @handler. * * Convenience function to make life easy to those who are writing * liboseaclient* function. It's more dificult to explain what does this * function do, so please see * @oseaclient_request_process_data/simple_data/nul_data function. **/ void oseaclient_request_call_user_function (AfDalRequestReturnData type, gpointer handler, gpointer user_data, gpointer oseaclient_data) { AfDalDataFunc data_handler; AfDalSimpleFunc simple_handler; AfDalNulFunc nul_handler; AfDalMultiFunc multi_handler; gboolean result = FALSE; g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "Executing user handler"); switch (type) { case AFDAL_REQUEST_DATA: data_handler = (AfDalDataFunc) handler; result = data_handler (oseaclient_data, user_data); break; case AFDAL_REQUEST_SIMPLE_DATA: simple_handler = (AfDalSimpleFunc) handler; result = simple_handler (oseaclient_data, user_data); break; case AFDAL_REQUEST_NUL_DATA: nul_handler = (AfDalNulFunc) handler; result = nul_handler (oseaclient_data, user_data); break; case AFDAL_REQUEST_MULTI_DATA: multi_handler = (AfDalMultiFunc) handler; result = multi_handler (oseaclient_data, user_data); break; } g_log (LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "User handler executed"); return; }
/** * Start Handler for the Expat parser. */ void start_handler(void* data, const XML_Char* name, const XML_Char** attributes) { struct state_t* state = (struct state_t*)data; struct conversion_t* c; unsigned i; ++state->depth; if (state->depth < DEPTH_MAX) { state->level[state->depth].tag = name; state->level[state->depth].data = 0; state->level[state->depth].len = 0; if (state->error == 0) { c = identify(state->depth, state->level); if (c) { state->level[state->depth].process = c->process; state->level[state->depth].process(state, token_open, 0, 0, attributes); } else { state->level[state->depth].process = 0; } for(i=0;attributes[i];i+=2) { const char* null_atts[1] = { 0 }; start_handler(data, attributes[i], null_atts); data_handler(data, attributes[i+1], strlen(attributes[i+1])); end_handler(data, attributes[i]); } } else { state->level[state->depth].process = 0; } } }
static void select(ClickRecognizerRef ref, void* context) { if(playing) return; playing = TRUE; layer_set_hidden(text_layer_get_layer(s_title_layer),TRUE); layer_set_hidden(text_layer_get_layer(s_bplay_layer),TRUE); layer_set_hidden(text_layer_get_layer(s_diff_layer),TRUE); data_handler(NULL); }
//used to control the leds void LED_CONTROL(int LED_NUMBER, int LED_COMMAND) { data_handler(LED_NUMBER,LED_COMMAND); // Slave address of TCA6507 is 0x45 (binary 1001 101) // false=write / true=read I2CMasterSlaveAddrSet(I2C0_MASTER_BASE, 0x45, false); // the for loop is there to make the code more compact and removes some redundant commands. int COUNTER; for (COUNTER=0;COUNTER!=5;COUNTER++) { if(COUNTER == 2) { //puts the command-byte in the dataput getting ready to sending it. I2CMasterDataPut(I2C0_MASTER_BASE, COMMAND_BYTE_INCREMENT); //starts sending the data. I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_START); } else if(COUNTER == 3) { //gets the first led_current_setting containing the byte for select0 ready to transmitting. I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[0] ); //keeps sending data. I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_CONT); } else if(COUNTER == 4) { //gets the second led_current_setting containing the byte for select1 ready to transmitting. I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[1] ); //keeps sending data. I2CMasterControl(I2C0_MASTER_BASE,I2C_MASTER_CMD_BURST_SEND_CONT); } else if(COUNTER == 5) { //gets the third led_current_setting containing the byte for select2 ready to transmitting. I2CMasterDataPut(I2C0_MASTER_BASE,led_current_setting[2] ); //transmitting the final byte and a stop command. I2CMasterControl(I2C0_MASTER_BASE, I2C_MASTER_CMD_BURST_SEND_FINISH ); } // Wait for I2C to finish. while(I2CMasterBusy(I2C0_MASTER_BASE)); //a short delay. SysCtlDelay(80000); } }
void send_rawip(void) { char *packet; packet = malloc(data_size); if (packet == NULL) { perror("[send_rawip] malloc()"); return; } memset(packet, 0, data_size); data_handler(packet, data_size); send_ip_handler(packet, data_size); free(packet); }
static void dtls_recv_handler(struct mbuf *mb, void *arg) { struct allocation *alloc = arg; struct sa src; int err; /* forward packet to TURN-client */ err = turnc_recv(alloc->turnc, &src, mb); if (err) { alloc->alloch(err, 0, NULL, NULL, NULL, alloc->arg); return; } /* available application data? */ if (mbuf_get_left(mb)) { data_handler(alloc, &src, mb); } }
void send_icmp_echo(void) { char *packet, *data; struct myicmphdr *icmp; packet = malloc(ICMPHDR_SIZE + data_size); if (packet == NULL) { perror("[send_icmp] malloc"); return; } memset(packet, 0, ICMPHDR_SIZE + data_size); icmp = (struct myicmphdr*) packet; data = packet + ICMPHDR_SIZE; /* fill icmp hdr */ icmp->type = opt_icmptype; /* echo replay or echo request */ icmp->code = opt_icmpcode; /* should be indifferent */ icmp->checksum = 0; icmp->un.echo.id = getpid() & 0xffff; icmp->un.echo.sequence = _icmp_seq; /* data */ data_handler(data, data_size); /* icmp checksum */ if (icmp_cksum == -1) icmp->checksum = cksum((u_short*)packet, ICMPHDR_SIZE + data_size); else icmp->checksum = icmp_cksum; /* adds this pkt in delaytable */ if (opt_icmptype == ICMP_ECHO) delaytable_add(_icmp_seq, 0, time(NULL), get_usec(), S_SENT); /* send packet */ send_ip_handler(packet, ICMPHDR_SIZE + data_size); free (packet); _icmp_seq++; }
static void data_handler2(void *opaque, int irq, int level) { data_handler(opaque, irq, level, 2); }
void send_icmp_other(void) { char *packet, *data, *ph_buf; struct myicmphdr *icmp; struct myiphdr icmp_ip; struct myudphdr *icmp_udp; int udp_data_len = 0; struct pseudohdr *pseudoheader; int left_space = IPHDR_SIZE + UDPHDR_SIZE + data_size; packet = malloc(ICMPHDR_SIZE + IPHDR_SIZE + UDPHDR_SIZE + data_size); ph_buf = malloc(PSEUDOHDR_SIZE + UDPHDR_SIZE + udp_data_len); if (packet == NULL || ph_buf == NULL) { perror("[send_icmp] malloc"); return; } memset(packet, 0, ICMPHDR_SIZE + IPHDR_SIZE + UDPHDR_SIZE + data_size); memset(ph_buf, 0, PSEUDOHDR_SIZE + UDPHDR_SIZE + udp_data_len); icmp = (struct myicmphdr*) packet; data = packet + ICMPHDR_SIZE; pseudoheader = (struct pseudohdr *) ph_buf; icmp_udp = (struct myudphdr *) (ph_buf + PSEUDOHDR_SIZE); /* fill icmp hdr */ icmp->type = opt_icmptype; /* ICMP_TIME_EXCEEDED */ icmp->code = opt_icmpcode; /* should be 0 (TTL) or 1 (FRAGTIME) */ icmp->checksum = 0; if (opt_icmptype == ICMP_REDIRECT) memcpy(&icmp->un.gateway, &icmp_gw.sin_addr.s_addr, 4); else icmp->un.gateway = 0; /* not used, MUST be 0 */ /* concerned packet headers */ /* IP header */ icmp_ip.version = icmp_ip_version; /* 4 */ icmp_ip.ihl = icmp_ip_ihl; /* IPHDR_SIZE >> 2 */ icmp_ip.tos = icmp_ip_tos; /* 0 */ icmp_ip.tot_len = htons((icmp_ip_tot_len ? icmp_ip_tot_len : (icmp_ip_ihl<<2) + UDPHDR_SIZE + udp_data_len)); icmp_ip.id = htons(getpid() & 0xffff); icmp_ip.frag_off = 0; /* 0 */ icmp_ip.ttl = 64; /* 64 */ icmp_ip.protocol = icmp_ip_protocol; /* 6 (TCP) */ icmp_ip.check = 0; memcpy(&icmp_ip.saddr, &icmp_ip_src.sin_addr.s_addr, 4); memcpy(&icmp_ip.daddr, &icmp_ip_dst.sin_addr.s_addr, 4); icmp_ip.check = cksum((__u16 *) &icmp_ip, IPHDR_SIZE); /* UDP header */ memcpy(&pseudoheader->saddr, &icmp_ip_src.sin_addr.s_addr, 4); memcpy(&pseudoheader->daddr, &icmp_ip_dst.sin_addr.s_addr, 4); pseudoheader->protocol = icmp_ip.protocol; pseudoheader->lenght = icmp_ip.tot_len; icmp_udp->uh_sport = htons(icmp_ip_srcport); icmp_udp->uh_dport = htons(icmp_ip_dstport); icmp_udp->uh_ulen = htons(UDPHDR_SIZE + udp_data_len); icmp_udp->uh_sum = cksum((__u16 *) ph_buf, PSEUDOHDR_SIZE + UDPHDR_SIZE + udp_data_len); /* filling icmp body with concerned packet header */ /* fill IP */ if (left_space == 0) goto no_space_left; memcpy(packet+ICMPHDR_SIZE, &icmp_ip, left_space); left_space -= IPHDR_SIZE; data += IPHDR_SIZE; if (left_space <= 0) goto no_space_left; /* fill UDP */ memcpy(packet+ICMPHDR_SIZE+IPHDR_SIZE, icmp_udp, left_space); left_space -= UDPHDR_SIZE; data += UDPHDR_SIZE; if (left_space <= 0) goto no_space_left; /* fill DATA */ data_handler(data, left_space); no_space_left: /* icmp checksum */ if (icmp_cksum == -1) icmp->checksum = cksum((u_short*)packet, ICMPHDR_SIZE + IPHDR_SIZE + UDPHDR_SIZE + data_size); else icmp->checksum = icmp_cksum; /* send packet */ send_ip_handler(packet, ICMPHDR_SIZE + IPHDR_SIZE + UDPHDR_SIZE + data_size); free (packet); free (ph_buf); }
int start_server(void (*data_handler)(const char *buf, const int len, const int socket_fd), int port_number) { int num_of_fd = 0; struct pollfd fds[MAX_CONN]; int len, socket_fd, tmp = 0; struct sockaddr_in sock; memset(fds, 0, sizeof(fds)); memset(&sock, 0, sizeof(sock)); if((socket_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { log_msg("socket() call failed"); exit(1); } port_number = (0 == port_number) ? DEFAULT_PORT : port_number; sock.sin_family = AF_INET; sock.sin_port = htons(port_number); len = INADDR_ANY; memset(&sock.sin_addr, len, sizeof(struct in_addr)); if(bind(socket_fd, (struct sockaddr *) &sock, sizeof(struct sockaddr_in)) < 0) { printf("bind() call failed\n"); close(socket_fd); exit(1); } if(setsockopt(socket_fd, SOL_SOCKET, SO_REUSEADDR, &tmp, sizeof(int)) < 0) { printf("setsockopt call failed\n"); } if(listen(socket_fd, 10) < 0) { printf("listen() call failed\n"); close(socket_fd); exit(1); } log_error("listening on port %d", port_number); fds[0].fd = socket_fd; fds[0].events = POLLIN; num_of_fd++; while(1) { int num_processed = 0; int ret = poll(fds, num_of_fd, TIMEOUT); if(ret == POLL_EXPIRE) { } else if(ret == POLL_ERR) { printf("Error in POLL aborting %s\n", strerror(errno)); break; } else { if(fds[0].revents & POLLIN) { socklen_t len = sizeof(struct sockaddr_in); int new_socket = accept(socket_fd, (struct sockaddr *)&sock, &len); if(num_of_fd < MAX_CONN) { fds[num_of_fd].fd = new_socket; fds[num_of_fd].events = POLLIN; fds[num_of_fd].revents = 0; num_of_fd++; log_msg("new incoming connection"); } else { log_msg("ignoring new connections as only 1024 simulatenous connections are supported"); } num_processed++; } for(int i = 1; (i < num_of_fd) && (num_processed < ret); i++) { num_processed++; if(fds[i].revents & POLLIN) { char buf[1024]; int len; len = read(fds[i].fd, buf, 1024); if(len == 0) { close(fds[i].fd); log_msg("fd %d closed I guess %d", fds[i].fd, num_of_fd); if(i != (num_of_fd-1)) { memcpy(&fds[i], &fds[num_of_fd-1], sizeof(struct pollfd)); i--; } num_of_fd--; } else { data_handler(buf, len, fds[i].fd); } } else if(fds[i].revents & POLLERR || (fds[i].revents & POLLNVAL)) { log_msg("fd = %d POLLERR|POLLNVAL", fds[i].fd); close(fds[i].fd); if(i < (num_of_fd-1)) { memcpy(&fds[i], &fds[num_of_fd-1], sizeof(struct pollfd)); i--; } num_of_fd--; } else if(fds[i].revents != 0) { log_msg("fd = %d UNKNOWN REVENT : %#x", fds[i].fd, fds[i].revents); } else num_processed--; } } } close(socket_fd); return 0; }
/*! ****************************************************************************** * @brief Decode byte per byte for each binary frame, being sensor data themselves * Incoming format is always sensorid timestamp fields * Output format will always be sensorname, timestamp, fields formated * @param[in] data pointer to next incoming token to be parsed * @param[in] tokenId token ID in the binary frame, start from 0 * @param[inout] bytesEaten the length of the frame analyzed, incremented based on fields length decoded * @return 0 keeps on processing next token / -1 end of frame ****************************************************************************** */ static int decode_one_binary_token(struct inv_icm30xxx * s, char * data, unsigned char tokenId ,unsigned short *bytesEaten) { unsigned char lIndx = 0; // this is sensorid field if ( tokenId == 0) { // parse decode_Frame array to check sensor_id is known do { if ( *data == decode_Frame[lIndx].sensor_id ) { // sensor found, print it on console s->response.sensorid = lIndx; // number of bytes analyzed for this is 1 char *bytesEaten = 1; // keep on processing current frame return 0; } lIndx++; } while (decode_Frame[lIndx].sensor_id != 0xFF ); // we reached end of decode_Frame array, this is an error, sensor id is unknown // stop processing current frame this has no sense return -1; } // this is timestamp field else if ( tokenId == 1) { // print timestamp on console unsigned long long int timestamp_64b = *( unsigned long long int*) data; s->response.payload.sensor_data.timestamp = (uint32_t) timestamp_64b; // number of bytes analyzed for this is 1 long long *bytesEaten += 8; } // this is payload data fields else { switch ( decode_Frame[s->response.sensorid].decodeFormat[tokenId-2] ) { case 'f' : // print float on console memcpy(&s->response.payload.sensor_data.data[4*(tokenId-2)], data, 4); // number of bytes analyzed for this is 1 float *bytesEaten += 4; break; case 'i' : // print integer on console memcpy(&s->response.payload.sensor_data.data[4*(tokenId-2)], data, 4); // number of bytes analyzed for this is 1 int *bytesEaten += 4; break; case 'F' : // print float on console together with carriage return memcpy(&s->response.payload.sensor_data.data[4*(tokenId-2)], data, 4); // number of bytes analyzed for this is 1 int *bytesEaten += 4; s->response.payload.sensor_data.len = *bytesEaten; /* signal the response */ s->response.event = true; // and end processing frame data_handler(s, decode_Frame[s->response.sensorid].sensor_id, s->response.payload.sensor_data.timestamp, (const uint8_t *)s->response.payload.sensor_data.data, *bytesEaten); return -1; case 'I' : // print integer on console together with carriage return memcpy(&s->response.payload.sensor_data.data[4*(tokenId-2)], data, 4); // number of bytes analyzed for this is 1 int *bytesEaten += 4; s->response.payload.sensor_data.len = *bytesEaten; /* signal the response */ s->response.event = true; // and end processing frame data_handler(s, decode_Frame[s->response.sensorid].sensor_id, s->response.payload.sensor_data.timestamp, (const uint8_t *)s->response.payload.sensor_data.data, *bytesEaten); return -1; default: // this is a 0 or unknown field, so end processing frame return -1; break; } } return 0; }
static void tcp_recv_handler(struct mbuf *mb_pkt, void *arg) { struct allocation *alloc = arg; int err = 0; /* re-assembly of fragments */ if (alloc->mb) { size_t pos; pos = alloc->mb->pos; alloc->mb->pos = alloc->mb->end; err = mbuf_write_mem(alloc->mb, mbuf_buf(mb_pkt), mbuf_get_left(mb_pkt)); if (err) goto out; alloc->mb->pos = pos; } else { alloc->mb = mem_ref(mb_pkt); } for (;;) { size_t len, pos, end; struct sa src; uint16_t typ; if (mbuf_get_left(alloc->mb) < 4) break; typ = ntohs(mbuf_read_u16(alloc->mb)); len = ntohs(mbuf_read_u16(alloc->mb)); if (typ < 0x4000) len += STUN_HEADER_SIZE; else if (typ < 0x8000) len += 4; else { err = EBADMSG; goto out; } alloc->mb->pos -= 4; if (mbuf_get_left(alloc->mb) < len) break; pos = alloc->mb->pos; end = alloc->mb->end; alloc->mb->end = pos + len; /* forward packet to TURN client */ err = turnc_recv(alloc->turnc, &src, alloc->mb); if (err) goto out; if (mbuf_get_left(alloc->mb)) { data_handler(alloc, &src, alloc->mb); } /* 4 byte alignment */ while (len & 0x03) ++len; alloc->mb->pos = pos + len; alloc->mb->end = end; if (alloc->mb->pos >= alloc->mb->end) { alloc->mb = mem_deref(alloc->mb); break; } } out: if (err) { alloc->alloch(err, 0, NULL, NULL, NULL, alloc->arg); } }
static void udp_recv(const struct sa *src, struct mbuf *mb, void *arg) { struct allocation *alloc = arg; data_handler(alloc, src, mb); }
static int parse_fifo(struct inv_icm30xxx * s, const uint8_t * buffer, uint32_t len) { int rc = 0; struct FifoProtocolPacket packet; uint32_t index = 0; int32_t remaining = (int32_t)len; inv_fifo_protocol_parse_packet_reset(&packet); packet.type = FIFOPROTOCOL_PACKET_TYPE_DATA; while(remaining >= FIFOPROTOCOL_PACKET_SIZE) { /* check header / footer */ if(buffer[index] != FIFOPROTOCOL_PROTECTED_HEADER || buffer[index+FIFOPROTOCOL_PACKET_SIZE-1] != FIFOPROTOCOL_PROTECTED_FOOTER) { INV_MSG(INV_MSG_LEVEL_VERBOSE, "Bad header/footer in fifo packet, dropping one byte..."); index += 1; remaining -= 1; continue; } /* header/footer ok - parse packet */ rc = inv_fifo_protocol_parse_packet_r(&packet, &buffer[index], FIFOPROTOCOL_PACKET_SIZE, s->fifop_exp_pkt_cnt); /* retry if parsing error with last packet */ if(rc == FIFOPROTOCOL_ERROR_PARSE) { INV_MSG(INV_MSG_LEVEL_VERBOSE, "Error parsing fifo packet. One packet lost." " Retrying with current packet..."); rc = inv_fifo_protocol_parse_packet_r(&packet, &buffer[index], FIFOPROTOCOL_PACKET_SIZE, s->fifop_exp_pkt_cnt); } /* invalid packet, skip it */ if(rc == FIFOPROTOCOL_ERROR_SIZE || rc == FIFOPROTOCOL_ERROR_PARSE) { INV_MSG(INV_MSG_LEVEL_VERBOSE, "Error parsing fifo packet. Dropping full packet..."); } /* valid packet, call handlers to notify upper layer */ else if(rc == FIFOPROTOCOL_ERROR_NO) { if(packet.type == FIFOPROTOCOL_PACKET_TYPE_ANSWER) { response_handler(s, packet.sensorid, (FifoProtocolCmd)packet.u.command.cmd, packet.arg, packet.size); } else { data_handler(s, packet.sensorid, packet.u.data.timestamp, packet.u.data.status, packet.u.data.accuracy, packet.arg, packet.size); } } else { /* incomplete packet */ } /* parse next packet */ index += FIFOPROTOCOL_PACKET_SIZE; remaining -= FIFOPROTOCOL_PACKET_SIZE; } /* If we did not receive all packets needed for current sensor id to be fully parsed, then make sure the already analyzed packet(s) will be part of next call to this function */ if (rc == FIFOPROTOCOL_ERROR_INCOMPLETE) { // INV_MSG(INV_MSG_LEVEL_DEBUG, "Incomplete fifo packet, rewind fifo index."); remaining += packet.states.packet_cnt * FIFOPROTOCOL_PACKET_SIZE; } /* return number of remaining bytes from input buffer */ return remaining; }