/** check EDNS at this IP and port */
static int
check_edns_ip(char* ip, int port, int info)
{
struct sockaddr_storage addr;
socklen_t len = 0;
uint8_t* wire;
size_t wlen;
memset(&addr, 0, sizeof(addr));
if(verb) printf("%s ", ip);
if(!convert_addr(ip, port, &addr, &len))
return 2;
/* try to send 3 times to the IP address, test root key */
if(!get_packet(&addr, len, ".", LDNS_RR_TYPE_DNSKEY, &wire, &wlen))
return 2;
if(!check_packet(wire, wlen, LDNS_RR_TYPE_DNSKEY))
return 1;
/* check support for caching type DS for chains of trust */
if(!get_packet(&addr, len, "se.", LDNS_RR_TYPE_DS, &wire, &wlen))
return 2;
if(!check_packet(wire, wlen, LDNS_RR_TYPE_DS))
return 1;
if(verb) printf("OK\n");
if(info) printf(" %s", ip);
return 0;
}
int main()
{
ogg_sync_state oy;
ogg_stream_state os;
int init=0;
ogg_packet op;
kate_state k;
kate_info ki;
kate_comment kc;
const kate_event *ev;
/* for the benefit of windows, which mangles data otherwise */
set_binary_file(stdin);
/* we initialize ogg and kate info/comment structures */
ogg_sync_init(&oy);
kate_info_init(&ki);
kate_comment_init(&kc);
/*
First, read the headers, which must appear first in a Kate stream. When
kate_decode_header returns a positive number, all headers have been seen
and we're ready to decode data.
*/
do {
get_packet(&oy,&os,&init,&op);
} while (kate_ogg_decode_headerin(&ki,&kc,&op)==0);
/*
We now have all the information we need from the headers, so we can
initialize kate for decoding
*/
kate_decode_init(&k,&ki);
/*
We can now read data, until kate_decode_packetin returns a positive
number, signaling the end of the stream
*/
while (1) {
if (get_packet(&oy,&os,&init,&op)) break;
if (kate_ogg_decode_packetin(&k,&op)>0) break;
/* we may have an event (eg, text) */
if (kate_decode_eventout(&k,&ev)==0) {
printf("Kate stream has text: %s\n",ev->text);
}
}
/* That's it, we can now cleanup */
ogg_stream_clear(&os);
ogg_sync_clear(&oy);
kate_clear(&k);
kate_info_clear(&ki);
kate_comment_clear(&kc);
return 0;
}
int parse_anza_SP (
uchar_t *packet,
ushort_t pkttype )
{
double ptime, ytime, sec;
ulong ysec;
int year, day, hour, min;
PktPar pack;
/* Get parameters for current datatype */
if( !get_packet( pkttype, &pack) ) return -1;
Par.staid = packet[6]*256 + packet[7];
Par.packet = pack;
Par.chan = -1;
Par.hdrtype = ( int )decode( pack.hdrtype );
ytime = now();
e2h( ytime, &year, &day, &hour, &min, &sec);
ptime = epoch( year * 1000 );
memcpy( (char *) &ysec, (char *) &packet[10], 4);
Par.time = ptime + ysec;
return (int) pkttype;
}
int get_packet(ogg_sync_state *oy,ogg_stream_state *os,int *init,ogg_packet *op)
{
char *buffer;
size_t bytes;
ogg_page og;
/* try to get a packet from the stream */
if (*init && ogg_stream_packetout(os,op)) return 0;
/* read data and feed the pages to ogg */
buffer=ogg_sync_buffer(oy,4096);
bytes=fread(buffer,1,4096,stdin);
if (bytes==0) return 1; /* we're done */
ogg_sync_wrote(oy,bytes);
while (ogg_sync_pageout(oy,&og)>0) {
if (!*init && ogg_page_bos(&og)) {
ogg_stream_init(os,ogg_page_serialno(&og));
}
ogg_stream_pagein(os,&og);
if (!*init && ogg_page_bos(&og)) {
ogg_packet op;
ogg_stream_packetpeek(os,&op);
if (op.bytes>=8 && !memcmp(op.packet,"\200kate\0\0\0",8)) {
*init=1;
}
else {
ogg_stream_clear(os);
}
}
}
/* try again with the new data */
return get_packet(oy,os,init,op);
}
/* check if there's a message from the server */
void get_server_message () {
int nr_active_sock, reclen, startptr = 0, msglen;
try_again:
nr_active_sock = SDLNet_CheckSockets (theset, 1);
if (nr_active_sock == 0) return;
if (!SDLNet_SocketReady (thesock)) return;
reclen = get_packet ();
if (reclen == -1) return;
if (reclen <= 0) {
log_error ("Disconnected by the server!\n");
exit_connection (EXIT_ALL);
exit (1);
}
msglen = *((short *) (msgbuf + startptr + 1));
msglen += 2;
if (process_message(msgbuf+startptr, msglen) == 0) {
/* something went wrong when processing our message. Log out. */
exit_connection (EXIT_ALL);
log_error ("Unable to process message");
exit (1);
}
goto try_again;
}
void vsync(DISPMANX_UPDATE_HANDLE_T u, void* arg)
{
int ret;
DISPMANX_UPDATE_HANDLE_T update;
update = vc_dispmanx_update_start( 10 );
assert( update );
ret = vc_dispmanx_element_change_source( update, element, resource[next_resource]);
assert( ret == 0 );
ret = vc_dispmanx_update_submit_sync( update );
assert( ret == 0 );
if(next_resource != 2) {
int real_next_resource = next_resource ^ 1;
next_resource = 2; // use filler if next callback called before this one ends
// fill image
int n;
for (n=0; n<HEIGHT; n+=2) {
get_packet(ROW(n)+24); // +24 because clock never changes
memcpy(ROW(n+1)+24, ROW(n)+24, 336); // double it up because the hardware scaler
// will introduce blurring between lines
}
// write to resource
ret = vc_dispmanx_resource_write_data( resource[real_next_resource], TYPE, PITCH, image, &image_rect );
assert( ret == 0 );
next_resource = real_next_resource; // queue up next real resource
}
}
/**
* sniff_packet()
* --------------
* the function to be called to read packet, do analysis, and update
* the internal structure.
* reads in p802.11 hdr, as well as ip hdr.
* highest level call used by sniffer_engine...
**/
void sniff_packet(struct SETTINGS *mySettings)
{
struct packet_info *packet;
/**
* read the packet, and handle the type of packet returned.
**/
if (DEBUG) printf("reading socket\n");
if (NULL == (packet = get_packet(mySettings)))
return;
if (DEBUG) printf("socket read ok\n");
if (mySettings->scan_mode == CHANNEL_SCAN){
process_channel_scan(packet);
}
else if (mySettings->scan_mode == DETAILED_SCAN){
if (mySettings->runtime_mode == DAEMONIZED)
mySettings->chosen_ap = NULL;
if (mySettings->chosen_ap != NULL)
process_detailed_scan(packet,
(struct access_point *)mySettings->chosen_ap);
else
process_detailed_scan(packet, NULL);
}
}
Error PacketPeer::get_var(Variant &r_variant) {
const uint8_t *buffer;
int buffer_size;
Error err = get_packet(&buffer, buffer_size);
if (err)
return err;
return decode_variant(r_variant, buffer, buffer_size, NULL, allow_object_decoding);
}
Error PacketPeer::get_var(Variant &r_variant) const {
const uint8_t *buffer;
int buffer_size;
Error err = get_packet(&buffer, buffer_size);
if (err)
return err;
return decode_variant(r_variant, buffer, buffer_size);
}
ECFG *get_ECFG(double time)
{
static ECFG Ecfg;
static uchar last_ndata[ECONFIG_SIZE];
static packet *pkn,*pkx;
static int different=1;
static packet_selector pks;
/* static packet_selector frmpks; */
/* static struct frameinfo_def frame; */
SET_PKS_BY_LASTT(pks,time,E_CFG_ID);
/*SET_PKS_BY_TIME(frmpks,time,E_CFG_ID); */
/*get_next_frame_struct(&frmpks,&frame);*/
Ecfg.time = time;
Ecfg.spin_period = SPIN_PERIOD; /* this must be made more dynamic */
/*Ecfg.spin_period = frame.spin_period; */
Ecfg.temperature = 9.3; /* default */
Ecfg.el_geom = GEOM_EL;
Ecfg.eh_geom = GEOM_EH;
pkn = get_packet(&pks);
if(pkn && !(pkn->quality & (~pkquality)))
different = memcmp(last_ndata, pkn->data, ECONFIG_SIZE);
if(different && check_econfig_pk_validity(pkn)){
if(pkn && !(pkn->quality & (~pkquality)))
memcpy(last_ndata,pkn->data,ECONFIG_SIZE);
decom_econfig(pkn,&Ecfg.norm_cfg);
initialize_eesa_high(&Ecfg);
initialize_eesa_low(&Ecfg);
different = 0;
Ecfg.valid++;
}
SET_PKS_BY_LASTT(pks,time,E_XCFG_ID);
pkx = get_packet(&pks);
decom_exconfig(pkx,&Ecfg.extd_cfg);
return(&Ecfg);
}
void feed_packets(int *sockfds, pcap_list_t *pkt_list) {
uint32_t list_len = get_pkt_list_length(pkt_list);
for (uint32_t i = 0; i < list_len; i++) {
pcap_pkt *input_pkt = get_packet(pkt_list, i);
int sockfd = sockfds[input_pkt->ifindex];
char *data = input_pkt->data;
int len = input_pkt->pcap_hdr.len;
if (sendto(sockfd, data, len, 0, 0, sizeof(struct sockaddr_ll)) < 0)
perror("sendto failed");
}
}
void gui_video_rotate_mode(struct GuiButton *gbtn)
{
struct Packet *pckt;
pckt = get_packet(my_player_number);
if (settings.video_rotate_mode) {
set_packet_action(pckt, PckA_SwitchView, 5, 0, 0, 0);
} else {
set_packet_action(pckt, PckA_SwitchView, 2, 0, 0, 0);
}
save_settings();
}
void packet_handler(int sig) {
packet_t pkt;
fprintf(stderr, "IN PACKET HANDLER, sig=%d %s \t\t pkt counter so far %d\n",
sig, strsignal(sig), pkt_cnt);
pkt = get_packet(cnt_msg); // the messages are of variable length. So, the 1st message consists of 1 packet, the 2nd message consists of 2 packets and so on..
pkt_total = pkt.how_many;
if (pkt_cnt == 0) { // when the 1st packet arrives, the size of the whole message is allocated.
message.num_packets = pkt_total;
message.data = (char*) mm_get(&MM,
message.num_packets * PACKET_DATA_SIZE + 1); // +1 for ending 0
fprintf(stderr, "=========Message address start \t %p \n",
message.data);
// message.data[pkt_total * PACKET_DATA_SIZE] = 0;
memset(message.data, 0, message.num_packets * PACKET_DATA_SIZE + 1);
}
// fprintf(stderr, "After get %d: \t|%s| \t\t%p\n", cnt_msg, message.data,
// message.data);
fprintf(stderr, "CURRENT MESSAGE %d with message total number %d, which %d and stuff %s\n",
cnt_msg, message.num_packets, pkt.which, pkt.data);
// fprintf(stderr, "Dest: ~%p~; \t Src: %p \t Size %d \t Offset %d (%d) \t @cnt %d\n",
// &message.data[0] + (PACKET_DATA_SIZE * pkt.which), pkt.data,
// PACKET_DATA_SIZE, pkt.which, PACKET_DATA_SIZE * pkt.which,pkt_cnt);
/* insert your code here ... stick packet in memory, make sure to handle duplicates appropriately */
if (message.data[PACKET_DATA_SIZE * pkt.which] == (char) 0) {
memcpy(message.data + (PACKET_DATA_SIZE * pkt.which), pkt.data,
PACKET_DATA_SIZE);
} else { // duplicated message deleted, skip this round
return;
}
++pkt_cnt;
if (pkt_cnt == message.num_packets) {
int i;
fputs("--------->",stderr);
for (i=0;i<(PACKET_DATA_SIZE*message.num_packets);++i){
// fputs("%d ",message.data[i],stderr);
fprintf(stderr,"%d ",(int)message.data[i]);
}
fputs("\n",stderr);
/*Print the packets in the correct order.*/
fprintf(stderr, "MSG %d: \t|%s| \t\t%p\n\n", cnt_msg, message.data,
message.data);
mm_put(&MM, (void*) message.data);
}
/*Deallocate message*/
}
//****************************************************************************
int CPacketList::get_packet_data(u8 *rbfr)
{
packet_list_p ptemp = get_packet();
if (ptemp == NULL) {
return -ERROR_NO_MORE_FILES ; // no packet available
}
// syslog("get: %u bytes\n", ptemp->bfr_len) ;
memcpy(rbfr, ptemp->bfr, ptemp->bfr_len) ;
int rx_bytes = ptemp->bfr_len ;
delete ptemp ;
return rx_bytes;
}
int netLoop(int tunFd)
{
char *tunPkt = NULL;
while(1)
{
tunPkt = get_packet(tunFd);
processPacket(tunPkt);
//tunPkt = NULL;
}
return 0;
}
//==========================================================================================
//接受处理数据包
int login_loop(pcap_t *pcap_handle)
{
struct pcap_pkthdr *pkt_header;
const u_char *pkt_data;//存储数据包的内容
int pcap_rec;
int time_cnt = 0;
int time_max = 500;//设置超时时间
struct packet_eap *p = get_packet();//数据包
//start验证
pcap_sendpacket(pcap_handle,p->start,18 + p->start[17]);
while ((pcap_rec = pcap_next_ex(pcap_handle,&pkt_header,&pkt_data)) != -1){
if((pcap_rec == 0) || (pkt_data[12]!=0x88) || (pkt_data[13]!=0x8e)){
if(time_cnt++ > time_max){//超时处理
printf("%s time out!!! need reconnect...\n", what_time());
time_cnt = 0;
}
continue;
}
switch(pkt_data[18]){
case 0x01://code:request
if ( pkt_data[22]==0x01){ //Type: identity[rfc3748] (1)
printf("%s response, identity\n", what_time());
p->id[19]=pkt_data[19];
pcap_sendpacket(pcap_handle,p->id,18 + p->id[17]);
}
if ( pkt_data[22]==0x04){ //Type: MD5-Challenge [RFC3748] (4)
make_passwd_pkt(p->passwd, pkt_data);
pcap_sendpacket(pcap_handle,p->passwd,18 + p->passwd[17]);
printf("%s resopnse, MD5-challenge\n", what_time());
}
break;
case 0x03://code:sussess
printf("%s %s login successfully\n", what_time(), username);
printf("%s press ctrl+c to logout...\n", what_time());
break;
case 0x04://code:failed
printf("%s %s login failed. unknow error\n", what_time(), username);
break;
}
}
return -1;
//==========================================================================================
}
int test_packet(unsigned short cnt) {
int conta = 0, ind = 0, r, ipc_status;
unsigned long irq_set, data;
char cmd;
message msg;
if ((irq_set = mouse_subscribe()) == -1) {
printf("Unable to subscribe mouse!\n");
return 1;
}
if (sys_outb(STAT_REG, ENABLE_MOUSE) != OK) //rato enable
printf("Error\n");
if (sys_outb(STAT_REG, W_TO_MOUSE) != OK) //MOUSE
printf("Error-MC\n");
if (sys_outb(OUT_BUF, ENABLE_SEND) != OK) //Ativar o envio
printf("Error-SEND\n");
while (cnt > conta) {
if ((r = driver_receive(ANY, &msg, &ipc_status)) != 0) {
printf("driver_receive failed with: %d", r);
continue;
}
if (is_ipc_notify(ipc_status)) {
switch (_ENDPOINT_P(msg.m_source)) {
case HARDWARE:
if (msg.NOTIFY_ARG & irq_set) {
get_packet();
mouse_print();
}
break;
default:
break;
}
} else {
}
}
printf("Terminou!\n");
if (sys_outb(STAT_REG, W_TO_MOUSE) != OK)
printf("ERROR-MC");
if (sys_outb(OUT_BUF, DISABLE_STREAM) != OK)
printf("ERROR-DISABLE_STREAM");
if (sys_inb(OUT_BUF, &data) != OK)
printf("OUT_BUF not full!\n");
if (data != ACK)
printf("Not ACK!\n");
if (mouse_unsubscribe() == -1)
printf("falhou unsubscribe mouse!\n");
return 0;
}
/*
* dump the file into the fd
*/
static void dump_file(gzFile fd, struct log_global_header *hdr)
{
struct log_header_packet pck;
struct log_header_info inf;
struct dissector_info infbuf;
u_char *pckbuf;
int count = 0;
/* loop until EOF */
LOOP {
switch (hdr->type) {
case LOG_INFO:
if (get_info(&inf, &infbuf) != E_SUCCESS) {
printf("\n");
return;
}
/* write the info */
put_info(fd, &inf, &infbuf);
SAFE_FREE(infbuf.user);
SAFE_FREE(infbuf.pass);
SAFE_FREE(infbuf.info);
SAFE_FREE(infbuf.banner);
break;
case LOG_PACKET:
if (get_packet(&pck, &pckbuf) != E_SUCCESS) {
printf("\n");
return;
}
/* write the data */
put_packet(fd, &pck, pckbuf);
SAFE_FREE(pckbuf);
break;
default:
FATAL_ERROR("Unknown log type");
break;
}
/* a dot every 10 packets */
if (count++ % 10 == 0) {
printf(".");
fflush(stdout);
}
}
}
void select_resurrect_creature(struct GuiButton *gbtn)
{
struct Dungeon *dungeon;
dungeon = get_my_dungeon();
int i;
i = selected_resurrect_creature(dungeon, gbtn);
if (i != -1)
{
struct CreatureStorage *cstore;
cstore = &dungeon->dead_creatures[i];
struct Packet *pckt;
pckt = get_packet(my_player_number);
set_packet_action(pckt, PckA_ResurrectCrtr, dungeon_special_selected, dungeon->owner | (cstore->model << 4) | (cstore->explevel << 12));
turn_off_menu(GMnu_RESURRECT_CREATURE);
}
}
/* Description: Wait for a DATA frame and store the payload.
* Author: Albin Severinson
* Date: 08/03/15
*/
bstring get_data_frame()
{
int rc = 0;
bstring packet;
//Wait for preamble to occur
rc = wait_for_preamble();
check(rc == 0, "Failed to get preamble.");
//Get packet
packet = get_packet();
return packet;
error:
return NULL;
}
void *handle_client_thread(void *ptr) {
Client *client = (Client *)ptr;
ClientWindow gfx = { 0 };
int running = 1;
//for reading data into
Buffer buf;
char *packet=NULL;
uint32_t packlen;
uint8_t cmd;
buf.buf = NULL;
printf("<%lu> got a connection ", pthread_self());
get_client_name(&(client->addr));
while (running) {
// 1. get single "packet"
printf("asking for a packet\n");
packlen = get_packet(client->sock, &buf, &packet);
printf("got a packet. Length: %zu\n", packlen);
if (packlen == 0){
running = 0;
break;
}
// 2. parse packet and perform command
cmd = (uint8_t) *packet++;
running = run_command(cmd, packet, packlen-1, client, &gfx);
// 3. repeat or cleanup
}
// X. cleanup and leave
printf("cleaning up client data\n");
if (gfx.window != 0){
destroy_window(&gfx); //graphics cleanup
}
close(client->sock); //network cleanup
free(buf.buf);
free(client);
//pthread_exit or return
return NULL;
}
void *handle_request(void *desc)
{
int sockd = ((struct client *)desc)->sockd;
char *addr = &(((struct client *)desc)->addr);
u_short port = ((struct client *)desc)->port;
//check ip
printf("Serving %s:%d\n\n", addr, port);
while(get_packet(sockd) == 0);
raw_close(sockd);
pthread_exit(0);
//exit(0);
}
void
packet_selection(GtkWidget *clist, gint row, gint column, GdkEventButton *event, gpointer data)
{
/* Fetch the packet from the cache */
union olsr_message *pack;
char *packet;
int y, x;
short size;
char *content[4];
int mem_size = 10;
content[0] = (char *)malloc(mem_size);
content[1] = (char *)malloc(mem_size);
content[2] = (char *)malloc(mem_size);
content[3] = (char *)malloc(mem_size);
pack = get_packet(row);
packet = (char *)pack;
//printf("Got the packet at row %d...\n", row);
gtk_clist_clear(GTK_CLIST(packet_content_list));
size = ntohs(pack->v4.olsr_msgsize);
for(y = 0; y < size;y += 4)
{
for(x = 0; x < 4; x++)
{
if(display_dec)
sprintf(content[x], "%03i", (u_char) packet[y+x]); /* Decimal format */
else
sprintf(content[x], "%02x", (u_char) packet[y+x]); /* Hex format */
}
gtk_clist_append(GTK_CLIST(packet_content_list), content);
}
free(content[0]);
free(content[1]);
free(content[2]);
free(content[3]);
}
int parse_pscl_IP (
uchar_t *packet,
ushort_t pkttype )
{
int nsamp, yr, day, hr, min, sec, msec;
ushort_t newtype;
PktPar pack;
char stime[64], key[64];
struct PsclPreHdr pkt;
int dasid;
/* Get parameters for current datatype */
newtype = PSCLIP;
if( !get_packet( newtype, &pack) ) return -1;
dasid = bcd2hex( &packet[4] , 4 );
Par.staid = dasid;
Par.chan = -1;
Par.packet = pack;
Par.hdrtype = ( int )decode( pack.hdrtype );
memcpy( (char *) &pkt, packet, sizeof( struct PsclPreHdr ));
yr = bcd2hex( pkt.year , 2 );
sprintf( (char *) &stime[0], "%02x%02x%02x%02x%02x%02x\0",
pkt.bcdtime[0], pkt.bcdtime[1], pkt.bcdtime[2],
pkt.bcdtime[3], pkt.bcdtime[4], pkt.bcdtime[5]);
sscanf( (char *) &stime[0], "%3d%2d%2d%2d%3d",
&day, &hr, &min, &sec, &msec);
if( yr < 50 )
sprintf( (char *) &stime[0], "20%02d%03d:%02d:%02d:%02d.%03d\0",
yr, day, hr, min, sec, msec);
else
sprintf( (char *) &stime[0], "19%02d%03d:%02d:%02d:%02d.%03d\0",
yr, day, hr, min, sec, msec);
Par.time = str2epoch( (char *) &stime[0] );
sprintf( &Par.packet.pkttype[0], "PSCLIP\0");
sprintf( (char *) &key[0], "%d", newtype );
setarr( RawPkts, (char *) &key[0], (char *) &Par.raw);
return (int) pkttype;
}
Error PacketPeer::get_packet_buffer(PoolVector<uint8_t> &r_buffer) const {
const uint8_t *buffer;
int buffer_size;
Error err = get_packet(&buffer, buffer_size);
if (err)
return err;
r_buffer.resize(buffer_size);
if (buffer_size == 0)
return OK;
PoolVector<uint8_t>::Write w = r_buffer.write();
for (int i = 0; i < buffer_size; i++)
w[i] = buffer[i];
return OK;
}
int main4()
{
int cnt = 1000000;
start_pres_server();
struct sched_pres *sp = (struct sched_pres*)buf;
uint8 no = 0;
while(1)
{
INFO("\033[1;33mtcp server... main4\033[0m \n");
if(!is_client_connected() && !have_packet())
{
no = 0;
DEBUG("no client!\n");
usleep(1000000);
}
if(have_packet())
{
int len = get_packet(buf, MAX_LEN);
CHECK2(len >=23 && len == sp->pkt_len);
INFO("Get a packet!\n dst_tel_code:%x\nsrc_tel_code:%x\n"
"pkt_len:%d\nno%d\ntime:%s\ndata_type:%x\ndata_sub_type:%x\n"
"test_len:%d\n",
sp->dst_tel_code, sp->src_tel_code, sp->pkt_len, sp->no, ctime(&sp->time),
sp->data_type, sp->data_sub_type, sp->text_len);
int i;
uint8 c = 0;
no++;
// DEBUG("should no:%d RECV_NO:%d\n", no, sp->no);
// CHECK2(no==sp->no);
for(i = 0; i < sp->text_len; i++)
{
if(sp->data[i] != c)
{
DEBUG("i = %d sp->data[i]==%d c==%d\n", i, sp->data[i], c);
CHECK2(sp->data[i]==c);
}
c++;
}
}
usleep(10000);
}
stop_pres_server();
}
int
mm_decode_video(mm_file *mf, SDL_Overlay *ovl)
{
int rv = 0;
ogg_packet pkt;
yuv_buffer yuv;
assert(mf);
if (!mf->video) {
return -1;
}
if (mf->drop_packets & MEDIA_VIDEO) {
WARNING1("requested decode but MEDIA_VIDEO is set to ignore");
return -1;
}
for (;;) {
rv = get_packet(mf, &pkt, MEDIA_VIDEO);
if (rv <= 0) {
return rv;
}
/* we got packet, decode */
if (theora_decode_packetin(mf->video_ctx, &pkt) == 0) {
break;
} else {
WARNING1("packet does not contain theora frame");
/* get next packet */
}
}
theora_decode_YUVout(mf->video_ctx, &yuv);
if (yuv_to_overlay(mf, &yuv, ovl) < 0) {
return -1;
}
return 1;
}
int ff_audio_rechunk_interleave(AVFormatContext *s, AVPacket *out, AVPacket *pkt, int flush,
int (*get_packet)(AVFormatContext *, AVPacket *, AVPacket *, int),
int (*compare_ts)(AVFormatContext *, AVPacket *, AVPacket *))
{
int i, ret;
if (pkt) {
AVStream *st = s->streams[pkt->stream_index];
AudioInterleaveContext *aic = st->priv_data;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
unsigned new_size = av_fifo_size(aic->fifo) + pkt->size;
if (new_size > aic->fifo_size) {
if (av_fifo_realloc2(aic->fifo, new_size) < 0)
return AVERROR(ENOMEM);
aic->fifo_size = new_size;
}
av_fifo_generic_write(aic->fifo, pkt->data, pkt->size, NULL);
} else {
// rewrite pts and dts to be decoded time line position
pkt->pts = pkt->dts = aic->dts;
aic->dts += pkt->duration;
if ((ret = ff_interleave_add_packet(s, pkt, compare_ts)) < 0)
return ret;
}
pkt = NULL;
}
for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
AVPacket new_pkt = { 0 };
while ((ret = interleave_new_audio_packet(s, &new_pkt, i, flush)) > 0) {
if ((ret = ff_interleave_add_packet(s, &new_pkt, compare_ts)) < 0)
return ret;
}
if (ret < 0)
return ret;
}
}
return get_packet(s, out, NULL, flush);
}
void packet_handler(int sig)
{
packet_t pkt;
// fprintf (stderr, "IN PACKET HANDLER, sig=%d\n", sig);
pkt = get_packet(cnt_msg); // the messages are of variable length. So, the 1st message consists of 1 packet, the 2nd message consists of 2 packets and so on..
pkt_total = pkt.how_many;
if(pkt_cnt==0){ // when the 1st packet arrives, the size of the whole message is allocated.
}
printf("CURRENT MESSAGE %d\n",cnt_msg);
/* insert your code here ... stick packet in memory, make sure to handle duplicates appropriately */
/*Print the packets in the correct order.*/
/*Deallocate message*/
}
void select_transfer_creature(struct GuiButton *gbtn)
{
struct Dungeon *dungeon;
dungeon = get_my_dungeon();
struct Thing *thing;
thing = INVALID_THING;
int listitm_idx;
listitm_idx = selected_transfer_creature(dungeon, gbtn);
if (listitm_idx != -1)
{
thing = get_player_list_nth_creature_of_model(dungeon->creatr_list_start, 0, listitm_idx);
}
if (thing_exists(thing))
{
struct Packet *pckt;
pckt = get_packet(my_player_number);
set_packet_action(pckt, PckA_TransferCreatr, dungeon_special_selected, thing->index);
turn_off_menu(GMnu_TRANSFER_CREATURE);
}
}
