inline void _filter<OSIFrameType, ParentFilterType>::parse(mutable_helper<typename ParentFilterType::frame_type> parent_helper) const { _base_filter<OSIFrameType>::clear_last_helper(); if (frame_parent_match<OSIFrameType, typename ParentFilterType::frame_type>(parent_helper)) { try { mutable_helper<OSIFrameType> helper(parent_helper.payload()); if (check_frame(helper)) { if (_base_filter<OSIFrameType>::filter_frame(helper)) { if (bridge_filter_frame(parent_helper, helper)) { _base_filter<OSIFrameType>::frame_handled(helper); } } } } catch (std::logic_error&) { } } }
static void process_input_buf (GstOmxBaseFilter * omx_base_filter, GstBuffer **buf) { GstOmxH264Dec *h264_self; h264_self = GST_OMX_H264DEC (omx_base_filter); if (h264_self->h264Format == GSTOMX_H264_FORMAT_UNKNOWN) { check_frame(h264_self, *buf); } if (h264_self->h264Format == GSTOMX_H264_FORMAT_3GPP) { if (omx_base_filter->last_pad_push_return != GST_FLOW_OK || !(omx_base_filter->gomx->omx_state == OMX_StateExecuting || omx_base_filter->gomx->omx_state == OMX_StatePause)) { GST_LOG_OBJECT(h264_self, "this frame will not be converted and go to out_flushing"); return; } GST_LOG_OBJECT(h264_self, "H264 format is 3GPP. convert to NALU"); convert_frame(h264_self, buf); } GST_OMX_BASE_FILTER_CLASS (parent_class)->process_input_buf (omx_base_filter, buf); }
static int action_start(struct sxplayer_ctx *s, int opt_test_flags) { int ret; struct sxplayer_frame *frame = sxplayer_get_frame(s, 0); if ((ret = check_frame(frame, 0, opt_test_flags)) < 0) return ret; sxplayer_release_frame(frame); return 0; }
int has_frame(uint8_t * data, size_t size) { size_t pos = 0; while(pos < size) { if(data[pos] == 0x7E) if(check_frame(data+pos, size-pos) == 0) return pos; ++pos; } return -1; }
/** * Repondre a une requete d'un joueur * NOTA: cette fonction est bloquante et attend une requete d'un joueur * * @param sock Socket du joueur ayant envoye une requete * @param the_players Liste des joueurs * @return Resultat de l'echange compose de 2 champs: * - type: correspond le plus souvent au type de trame * ou a une fin de connexion * - content: correspond au contenu brut de l'echange, a savoir * une structure Player, un identifiant ou un ordre. */ Result* respond(int sock, Players the_players) { Result* result = NULL; Frame frame = recv_frame(sock); /*debug*/ print_frame(frame); if(check_frame(frame) == SUCCESS) { /* Deconnexion du joueur */ if(frame->pennant == SPECIAL_FRAME) { result = malloc(sizeof(Result)); remove_player_by_sock(sock, the_players, 1); result->type = NOT_CONNECTED; result->content = NULL; /* Traitement du serveur a la requete du client */ } else { switch(frame->id) { case Connect: result = respond_connect(sock, the_players, frame); break; case Initiate: result = respond_initiate(sock, the_players, frame); break; case Order: result = respond_order(sock, the_players, frame); break; /* Type de trame inconnu ou non autorisee du protocole * @todo si type de trame existant, renvoyer une erreur specifique */ default: PRINT_UNKNOWN_FRAME_TYPE(frame->id); break; } } } if(frame != NULL) { free_frame(frame); } return result; }
static int action_middle(struct sxplayer_ctx *s, int opt_test_flags) { int ret; struct sxplayer_frame *f0 = sxplayer_get_frame(s, 30.0); struct sxplayer_frame *f1 = sxplayer_get_frame(s, 30.1); struct sxplayer_frame *f2 = sxplayer_get_frame(s, 30.2); struct sxplayer_frame *f3 = sxplayer_get_frame(s, 15.0); struct sxplayer_frame *f4 = sxplayer_get_next_frame(s); struct sxplayer_frame *f5 = sxplayer_get_next_frame(s); const double increment = opt_test_flags & FLAG_AUDIO ? SOURCE_SPF/(float)SOURCE_FREQ : 1./SOURCE_FPS; if ((ret = check_frame(f0, 30.0, opt_test_flags)) < 0 || (ret = check_frame(f1, 30.1, opt_test_flags)) < 0 || (ret = check_frame(f2, 30.2, opt_test_flags)) < 0 || (ret = check_frame(f3, 15.0, opt_test_flags)) < 0 || (ret = check_frame(f4, 15.0 + 1*increment, opt_test_flags)) < 0 || (ret = check_frame(f5, 15.0 + 2*increment, opt_test_flags)) < 0) return ret; sxplayer_release_frame(f0); sxplayer_release_frame(f5); sxplayer_release_frame(f1); sxplayer_release_frame(f4); sxplayer_release_frame(f2); sxplayer_release_frame(f3); f0 = sxplayer_get_next_frame(s); f1 = sxplayer_get_frame(s, 16.0); f2 = sxplayer_get_frame(s, 16.001); if ((ret = check_frame(f0, 15.0 + 3*increment, opt_test_flags)) < 0 || (ret = check_frame(f1, 16.0, opt_test_flags)) < 0) return ret; if (f2) { fprintf(stderr, "got f2\n"); return -1; } sxplayer_release_frame(f1); sxplayer_release_frame(f0); return 0; }
inline void _base_filter<OSIFrameType>::do_parse(boost::asio::mutable_buffer buf) const { try { mutable_helper<OSIFrameType> helper(buf); if (check_frame(helper)) { if (_base_filter<OSIFrameType>::filter_frame(helper)) { _base_filter<OSIFrameType>::frame_handled(helper); } } } catch (std::logic_error&) { } }
void handle_request(int fd, struct link *link, bool check_bootable) { memset(link->buf, 0, sizeof(link->buf)); memset(&link->src, 0, sizeof(link->src)); ssize_t size = read_request(fd, &link->src, link->buf, sizeof(link->buf)); if (size <= 0) { return; } if (!check_frame(&link->src, link)) { return; } if ((size_t) size < sizeof(struct ether_arp)) { XLOG_WARNING("request to short"); return; } struct ether_arp *arp_req = (struct ether_arp *)link->buf; if (!check_request(arp_req, &link->src)) { return; } struct in_addr ip; memset(&ip, 0, sizeof(in_addr_t)); int ret = resolve((struct ether_addr*)&arp_req->arp_tha, &ip); if (ret != 0) { return; } XLOG_DEBUG("found address: %s", inet_ntoa(ip)); if (check_bootable == true && !is_bootable(ip)) { return; } create_reply(arp_req, &ip, link); dispatcher_flags(&link->handler, POLLOUT); }
int main(int argc, char *argv[]) { int fd; int res, x; struct dahdi_params tp; struct dahdi_bufferinfo bi; int bs = BLOCK_SIZE; int pos = 0; unsigned char inbuf[BLOCK_SIZE]; unsigned char outbuf[BLOCK_SIZE]; int bytes = 0; int out; unsigned int olddata1; int oldones1; int oldbits1; unsigned int olddata = 0; int oldones = 0; int oldbits = 0; int hdlcmode = 0; struct fasthdlc_state fs; if (argc < 2) { fprintf(stderr, "Usage: %s <DAHDI device>\n", argv[0]); exit(1); } fd = open(argv[1], O_RDWR, 0600); if (fd < 0) { fprintf(stderr, "Unable to open %s: %s\n", argv[1], strerror(errno)); exit(1); } if (ioctl(fd, DAHDI_SET_BLOCKSIZE, &bs)) { fprintf(stderr, "Unable to set block size to %d: %s\n", bs, strerror(errno)); exit(1); } if (ioctl(fd, DAHDI_GET_PARAMS, &tp)) { fprintf(stderr, "Unable to get channel parameters\n"); exit(1); } if ((tp.sigtype & DAHDI_SIG_HDLCRAW) == DAHDI_SIG_HDLCRAW) { printf("In HDLC mode\n"); hdlcmode = 1; } else if ((tp.sigtype & DAHDI_SIG_CLEAR) == DAHDI_SIG_CLEAR) { printf("In CLEAR mode\n"); hdlcmode = 0; } else { fprintf(stderr, "Not in a reasonable mode\n"); exit(1); } res = ioctl(fd, DAHDI_GET_BUFINFO, &bi); if (!res) { bi.txbufpolicy = DAHDI_POLICY_IMMEDIATE; bi.rxbufpolicy = DAHDI_POLICY_IMMEDIATE; bi.numbufs = 4; res = ioctl(fd, DAHDI_SET_BUFINFO, &bi); if (res < 0) { fprintf(stderr, "Unable to set buf info: %s\n", strerror(errno)); exit(1); } } else { fprintf(stderr, "Unable to get buf info: %s\n", strerror(errno)); exit(1); } ioctl(fd, DAHDI_GETEVENT); fasthdlc_precalc(); fasthdlc_init(&fs, FASTHDLC_MODE_64); for (;;) { res = read(fd, outbuf, sizeof(outbuf)); if (hdlcmode) { if (res < 0) { if (errno == ELAST) { if (ioctl(fd, DAHDI_GETEVENT, &x) < 0) { fprintf(stderr, "Unaable to get event: %s\n", strerror(errno)); exit(1); } fprintf(stderr, "Event: %d (%d bytes since last error)\n", x, bytes); bytes = 0; continue; } else { fprintf(stderr, "Error: %s\n", strerror(errno)); exit(1); } } #if 0 printf("Res is %d, buf0 is %d, buf1 is %d\n", res, outbuf[0], outbuf[1]); #endif if (res < 2) { fprintf(stderr, "Too small? Only got %d bytes\n", res); } check_frame(outbuf, res); } else { for (x = 0; x < res; x++) { oldones1 = oldones; oldbits1 = oldbits; olddata1 = olddata; oldones = fs.ones; oldbits = fs.bits; olddata = fs.data; fasthdlc_rx_load(&fs, outbuf[x]); out = fasthdlc_rx_run(&fs); if (out & RETURN_EMPTY_FLAG) { /* Empty */ } else if (out & RETURN_COMPLETE_FLAG) { if (pos && (pos < 2)) { printf("Too short? (%d)\n", pos); } else if (pos) { check_frame(inbuf, pos); } pos = 0; } else if (out & RETURN_DISCARD_FLAG) { printf("Discard (search = %d, len = %d, buf = %d, x=%d, res=%d, oldones: %d, oldbits: %d)\n", c, pos, inbuf[0], x, res, oldones, oldbits); dump_bitslong(olddata, oldbits); printf("Discard oldones: %d, oldbits: %d)\n", oldones1, oldbits1); dump_bitslong(olddata1, oldbits1); if (x > 64) { dump_bits(outbuf + x - 64, 64); dump_bits(outbuf + x, 64); } pos = 0; } else { if ((out != c) && (pos < c) && !pos) { printf("Warning: Expecting %d at pos %d, got %d (x =%d)\n", c, pos, out, x); if (x > 64) { dump_bits(outbuf + x - 64, 64); dump_bits(outbuf + x, 64); } } inbuf[pos++] = out; } } } } }
code_block *frame_code(stack_frame *frame) { check_frame(frame); return (code_block *)frame->xt - 1; }
stack_frame *frame_successor(stack_frame *frame) { check_frame(frame); return (stack_frame *)((cell)frame - frame->size); }
code_block *factor_vm::frame_code(stack_frame *frame) { check_frame(frame); return (code_block *)frame->entry_point - 1; }
/* isdnhdlc_decode - decodes HDLC frames from a transparent bit stream. The source buffer is scanned for valid HDLC frames looking for flags (01111110) to indicate the start of a frame. If the start of the frame is found, the bit stuffing is removed (0 after 5 1's). When a new flag is found, the complete frame has been received and the CRC is checked. If a valid frame is found, the function returns the frame length excluding the CRC with the bit HDLC_END_OF_FRAME set. If the beginning of a valid frame is found, the function returns the length. If a framing error is found (too many 1s and not a flag) the function returns the length with the bit HDLC_FRAMING_ERROR set. If a CRC error is found the function returns the length with the bit HDLC_CRC_ERROR set. If the frame length exceeds the destination buffer size, the function returns the length with the bit HDLC_LENGTH_ERROR set. src - source buffer slen - source buffer length count - number of bytes removed (decoded) from the source buffer dst _ destination buffer dsize - destination buffer size returns - number of decoded bytes in the destination buffer and status flag. */ int isdnhdlc_decode(struct isdnhdlc_vars *hdlc, const u8 *src, int slen, int *count, u8 *dst, int dsize) { int status = 0; static const unsigned char fast_flag[] = { 0x00, 0x00, 0x00, 0x20, 0x30, 0x38, 0x3c, 0x3e, 0x3f }; static const unsigned char fast_flag_value[] = { 0x00, 0x7e, 0xfc, 0xf9, 0xf3, 0xe7, 0xcf, 0x9f, 0x3f }; static const unsigned char fast_abort[] = { 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff }; #define handle_fast_flag(h) \ do { \ if (h->cbin == fast_flag[h->bit_shift]) { \ h->ffvalue = fast_flag_value[h->bit_shift]; \ h->state = HDLC_FAST_FLAG; \ h->ffbit_shift = h->bit_shift; \ h->bit_shift = 1; \ } else { \ h->state = HDLC_GET_DATA; \ h->data_received = 0; \ } \ } while (0) #define handle_abort(h) \ do { \ h->shift_reg = fast_abort[h->ffbit_shift - 1]; \ h->hdlc_bits1 = h->ffbit_shift - 2; \ if (h->hdlc_bits1 < 0) \ h->hdlc_bits1 = 0; \ h->data_bits = h->ffbit_shift - 1; \ h->state = HDLC_GET_DATA; \ h->data_received = 0; \ } while (0) *count = slen; while (slen > 0) { if (hdlc->bit_shift == 0) { /* the code is for bitreverse streams */ if (hdlc->do_bitreverse == 0) hdlc->cbin = bitrev8(*src++); else hdlc->cbin = *src++; slen--; hdlc->bit_shift = 8; if (hdlc->do_adapt56) hdlc->bit_shift--; } switch (hdlc->state) { case STOPPED: return 0; case HDLC_FAST_IDLE: if (hdlc->cbin == 0xff) { hdlc->bit_shift = 0; break; } hdlc->state = HDLC_GET_FLAG_B0; hdlc->hdlc_bits1 = 0; hdlc->bit_shift = 8; break; case HDLC_GET_FLAG_B0: if (!(hdlc->cbin & 0x80)) { hdlc->state = HDLC_GETFLAG_B1A6; hdlc->hdlc_bits1 = 0; } else { if ((!hdlc->do_adapt56) && (++hdlc->hdlc_bits1 >= 8) && (hdlc->bit_shift == 1)) hdlc->state = HDLC_FAST_IDLE; } hdlc->cbin <<= 1; hdlc->bit_shift--; break; case HDLC_GETFLAG_B1A6: if (hdlc->cbin & 0x80) { hdlc->hdlc_bits1++; if (hdlc->hdlc_bits1 == 6) hdlc->state = HDLC_GETFLAG_B7; } else hdlc->hdlc_bits1 = 0; hdlc->cbin <<= 1; hdlc->bit_shift--; break; case HDLC_GETFLAG_B7: if (hdlc->cbin & 0x80) { hdlc->state = HDLC_GET_FLAG_B0; } else { hdlc->state = HDLC_GET_DATA; hdlc->crc = 0xffff; hdlc->shift_reg = 0; hdlc->hdlc_bits1 = 0; hdlc->data_bits = 0; hdlc->data_received = 0; } hdlc->cbin <<= 1; hdlc->bit_shift--; break; case HDLC_GET_DATA: if (hdlc->cbin & 0x80) { hdlc->hdlc_bits1++; switch (hdlc->hdlc_bits1) { case 6: break; case 7: if (hdlc->data_received) /* bad frame */ status = -HDLC_FRAMING_ERROR; if (!hdlc->do_adapt56) { if (hdlc->cbin == fast_abort [hdlc->bit_shift + 1]) { hdlc->state = HDLC_FAST_IDLE; hdlc->bit_shift = 1; break; } } else hdlc->state = HDLC_GET_FLAG_B0; break; default: hdlc->shift_reg >>= 1; hdlc->shift_reg |= 0x80; hdlc->data_bits++; break; } } else { switch (hdlc->hdlc_bits1) { case 5: break; case 6: if (hdlc->data_received) status = check_frame(hdlc); hdlc->crc = 0xffff; hdlc->shift_reg = 0; hdlc->data_bits = 0; if (!hdlc->do_adapt56) handle_fast_flag(hdlc); else { hdlc->state = HDLC_GET_DATA; hdlc->data_received = 0; } break; default: hdlc->shift_reg >>= 1; hdlc->data_bits++; break; } hdlc->hdlc_bits1 = 0; } if (status) { hdlc->dstpos = 0; *count -= slen; hdlc->cbin <<= 1; hdlc->bit_shift--; return status; } if (hdlc->data_bits == 8) { hdlc->data_bits = 0; hdlc->data_received = 1; hdlc->crc = crc_ccitt_byte(hdlc->crc, hdlc->shift_reg); /* good byte received */ if (hdlc->dstpos < dsize) dst[hdlc->dstpos++] = hdlc->shift_reg; else { /* frame too long */ status = -HDLC_LENGTH_ERROR; hdlc->dstpos = 0; } } hdlc->cbin <<= 1; hdlc->bit_shift--; break; case HDLC_FAST_FLAG: if (hdlc->cbin == hdlc->ffvalue) { hdlc->bit_shift = 0; break; } else { if (hdlc->cbin == 0xff) { hdlc->state = HDLC_FAST_IDLE; hdlc->bit_shift = 0; } else if (hdlc->ffbit_shift == 8) { hdlc->state = HDLC_GETFLAG_B7; break; } else handle_abort(hdlc); } break; default: break; }
Map::size_type Map::set_frame(size_type size) { return m_frame = check_frame(size); }
Map::Map(const Facade & wf, size_type size, bool write) : m_size(simstd::min(wf.size(), size)), m_frame(check_frame(DEFAULT_FRAME)), m_map(CheckHandle(::CreateFileMapping(wf, nullptr, (write) ? PAGE_READWRITE : PAGE_READONLY, high_part_64(m_size), low_part_64(m_size), nullptr))), m_write(write) { }