int get_ip_port_from_sdp(char *sdp_text, in_addr_t *addr, unsigned short *port){
unsigned long l;
char *s;
char s1[20];
s=gettag(sdp_text,strlen(sdp_text),"c=IN IP4 ",&l);
memset(s1,'\0',sizeof(s1));
memcpy(s1,s,MIN(l,19));
if ((long)(*addr=inet_addr(s1))==-1){
*addr=0;
*port=0;
return 1;
}
s=gettag(sdp_text,strlen(sdp_text),"m=audio ",&l);
if (l==0){
s=gettag(sdp_text,strlen(sdp_text),"m=image ",&l);
}
if (l==0 || (*port=atoi(s))==0){
*port=0;
return 1;
}
return 0;
}
static int scanner(lua_State *L) {
gdcm::Scanner scn;
gdcm::Directory d;
const char* dirname = luaL_checkstring(L, 1);
luaL_checktype(L, 2, LUA_TTABLE); // table containing dicom tags
bool recurse = (1 == lua_toboolean(L, 3)); // whether recursion is performed
d.Load( dirname, recurse ); // Load files from directory; recursively
int k, N = luaL_len(L, 2); // N is the number of tags
unsigned int j[2];
gdcm::Tag tags[N];
for (k=0; k < N; k++) {
lua_rawgeti(L, 2, k+1);
gettag(L, j);
lua_pop(L, 1);
tags[k] = gdcm::Tag(j[0], j[1]);
scn.AddTag( tags[k] );
}
if (!scn.Scan( d.GetFilenames() )) {lua_pushnil(L); lua_pushfstring(L, "Unable to scan directory: %s.\n", dirname); return 2;}
gdcm::Directory::FilenamesType files = scn.GetKeys(); // it is a vector structure
if ( !files.empty() ) {
lua_newtable(L);
int m = 1; // Number of files
for (gdcm::Directory::FilenamesType::const_iterator file = files.begin(); file != files.end(); ++file) {
lua_newtable(L);
const char *fname = file->c_str();
lua_pushstring(L, fname);
lua_rawseti(L, -2, 1);
for (k=0; k<N; k++) {
lua_pushstring(L, scn.GetValue(fname, tags[k]));
if (lua_isnumber(L, -1) == 1) {
lua_pushnumber(L, lua_tonumber(L, -1));
lua_remove(L, -2);
}
if (lua_isnoneornil(L, -1) == 1) {
lua_pop(L, 1);
lua_pushstring(L, "");
}
lua_rawseti(L, -2, k+2);
}
lua_rawseti(L, -2, m++);
}
} else
{lua_pushnil(L); lua_pushfstring(L, "Unable to find DCM files in directory: %s.\n", dirname); return 2;}; //luaL_error(L, "Unable to read directory.");
return 1;
}
int main(int argc,char** argv)
{
char property[MAX_PROPERTY];
char value[MAX_VALUE];
char tag[MAX_TAG];
int do_next=0;
char* fullurl=NULL;
char* baseurl=NULL;
if (argc>1)
baseurl=argv[1];
while (gettag(stdin,tag)) {
if (!IS_LINK_TAG(tag)) continue;
DEBUG_PRINT_STR(tag);
while (getproperty(stdin,property)) {
if (!IS_LINK_PROP(property)) continue;
DEBUG_PRINT_STR(property);
do_next=getvalue(stdin,value);
DEBUG_PRINT_STR(value);
if (do_next) {
fullurl=getfullurl(value,baseurl);
if (fullurl!=NULL) {
printf("%s\n",fullurl);
free(fullurl);
}
}
}
}
while (0) {
do_next=getproperty(stdin,property);
// printf("%s=",property);
if (!do_next) break;
do_next=getvalue(stdin,value);
if (IS_LINK(property)) {
fullurl=getfullurl(value,baseurl);
if (fullurl!=NULL) {
printf("%s\n",fullurl);
free(fullurl);
}
}
if (!do_next) break;
}
return 0;
}
int I_ReadSigSet(FILE * fd, struct SigSet *S)
{
char tag[256];
I_InitSigSet(S);
while (gettag(fd, tag)) {
if (eq(tag, "title:"))
get_title(fd, S);
if (eq(tag, "nbands:"))
get_nbands(fd, S);
if (eq(tag, "class:"))
get_class(fd, S);
}
return 1; /* for now assume success */
}
static int readImageHeader(lua_State *L) {
luaL_checktype(L, 2, LUA_TTABLE);
int k, N = luaL_len(L, 2);
unsigned int j[2];
gdcm::Tag tags[N];
for (k=0; k < N; k++) {
lua_rawgeti(L, 2, k+1);
gettag(L, j);
lua_pop(L, 1);
tags[k] = gdcm::Tag(j[0], j[1]);
}
lua_pushinteger(L, getHeader(L, luaL_checkstring(L, 1), tags, N)); // number of missing values
return 2;
}
/*
* get_dbpath --
* Read the path of the database from man.conf and return.
*/
char *
get_dbpath(const char *manconf)
{
TAG *tp;
char *dbpath;
config(manconf);
tp = gettag("_mandb", 1);
if (!tp)
return NULL;
if (TAILQ_EMPTY(&tp->entrylist))
return NULL;
dbpath = TAILQ_LAST(&tp->entrylist, tqh)->s;
return dbpath;
}
static int get_subclass(FILE * fd, struct SigSet *S, struct ClassSig *C)
{
struct SubSig *Sp;
char tag[1024];
Sp = I_NewSubSig(S, C);
while (gettag(fd, tag)) {
if (eq(tag, "endsubclass:"))
break;
if (eq(tag, "pi:"))
get_subclass_pi(fd, Sp);
if (eq(tag, "means:"))
get_subclass_means(fd, Sp, S->nbands);
if (eq(tag, "covar:"))
get_subclass_covar(fd, Sp, S->nbands);
}
return 0;
}
int get_sip_peername(char *data, int data_len, const char *tag, char *peername, int peername_len){
unsigned long r,r2,peername_tag_len;
char *peername_tag=gettag(data,data_len,tag,&peername_tag_len);
if ((r=(unsigned long)memmem(peername_tag,peername_tag_len,"sip:",4))==0){
goto fail_exit;
}
r+=4;
if ((r2=(unsigned long)memmem(peername_tag,peername_tag_len,"@",1))==0){
goto fail_exit;
}
if (r2<=r){
goto fail_exit;
}
memcpy(peername,(void*)r,r2-r);
memset(peername+(r2-r),0,1);
return 0;
fail_exit:
strcpy(peername,"empty");
return 1;
}
static void io_writeto (void)
{
FILE *current;
lua_Object f = lua_getparam(FIRSTARG);
if (f == LUA_NOOBJECT) {
closefile(FOUTPUT);
current = stdout;
}
else if (lua_tag(f) == gettag(IOTAG))
current = lua_getuserdata(f);
else {
char *s = luaL_check_string(FIRSTARG);
current = (*s == '|') ? popen(s+1,"w") : fopen(s,"w");
if (current == NULL) {
pushresult(0);
return;
}
}
setreturn(current, FOUTPUT);
}
rs_result
rs_build_hash_table(rs_signature_t * sums)
{
int i;
sums->tag_table = calloc(TABLE_SIZE, sizeof(sums->tag_table[0]));
if (!sums->tag_table)
return RS_MEM_ERROR;
if (sums->count > 0) {
sums->targets = calloc(sums->count, sizeof(rs_target_t));
if (!sums->targets) {
free(sums->tag_table);
sums->tag_table = NULL;
return RS_MEM_ERROR;
}
for (i = 0; i < sums->count; i++) {
sums->targets[i].i = i;
sums->targets[i].t = gettag(sums->block_sigs[i].weak_sum);
}
heap_sort(sums);
}
for (i = 0; i < TABLE_SIZE; i++) {
sums->tag_table[i].l = NULL_TAG;
sums->tag_table[i].r = NULL_TAG;
}
for (i = sums->count - 1; i >= 0; i--) {
sums->tag_table[sums->targets[i].t].l = i;
}
for (i = 0; i < sums->count; i++) {
sums->tag_table[sums->targets[i].t].r = i;
}
rs_trace("rs_build_hash_table done");
return RS_DONE;
}
static int get_class(FILE * fd, struct SigSet *S)
{
char tag[1024];
struct ClassSig *C;
C = I_NewClassSig(S);
while (gettag(fd, tag)) {
if (eq(tag, "endclass:"))
break;
if (eq(tag, "classnum:"))
get_classnum(fd, C);
if (eq(tag, "classtype:"))
get_classtype(fd, C);
if (eq(tag, "classtitle:"))
get_classtitle(fd, C);
if (eq(tag, "subclass:"))
get_subclass(fd, S, C);
}
return 0;
}
static void io_readfrom() {
lua_Object f = lua_getparam(FIRSTARG);
if (f == LUA_NOOBJECT) {
if (getfile(FOUTPUT) != getfile(1)) {
closefile(FINPUT);
setreturn(1, FINPUT);
}
} else if (lua_tag(f) == gettag(IOTAG)) {
int32 id = lua_getuserdata(f);
LuaFile *current = getfile(id);
if (!current) {
pushresult(0);
return;
}
setreturn(id, FINPUT);
} else {
const char *s = luaL_check_string(FIRSTARG);
Common::String fileName = Common::lastPathComponent(s, '\\');
LuaFile *current = NULL;
Common::SeekableReadStream *inFile = NULL;
Common::SaveFileManager *saveFileMan = g_system->getSavefileManager();
inFile = saveFileMan->openForLoading(fileName);
if (!inFile) {
inFile = g_resourceloader->openNewStreamFile(s);
}
if (inFile) {
current = new LuaFile();
current->_in = inFile;
current->_filename = s;
} else {
warning("liolib.cpp, io_readfrom(): Could not open file %s", s);
}
if (!current) {
delete current;
pushresult(0);
} else {
setreturn(addfile(current), FINPUT);
}
}
}
/**
* anchor_get: return the specified anchor
*
* @param[in] name name of anchor
* @param[in] length lenght of the name
* @param[in] type ==0: not specified <br>
* !=0: D, M, T, R, Y
* @param[in] lineno line number
*/
struct anchor *
anchor_get(const char *name, int length, int type, int lineno)
{
struct anchor *p = curp ? curp : start;
if (table == NULL)
return NULL;
if (p->lineno > lineno)
return NULL;
/*
* set pointer to the top of the cluster.
*/
for (; p < end && p->lineno < lineno; p++)
;
if (p >= end || p->lineno != lineno)
return NULL;
curp = p;
for (; p < end && p->lineno == lineno; p++)
if (!p->done && p->length == length && !strcmp(gettag(p), name))
if (!type || p->type == type)
return p;
return NULL;
}
void Store(mem_addr_t* addr)
{
cache_set_t this_set=cache[getset(addr)];
int index;
for (index = 0; index < E; index++)
{
if ((this_set[index]).valid == '1' && gettag(addr) == (this_set[index]).tag) //found
{
(this_set[index]).lru = ++lru_counter;
break;
}
}
if (index == E) // store miss
{
Load(addr); // if miss, then load
}
else // store hit
{
hit_count++;
}
}
/*
* See if there is a match for the specified block INBUF..BLOCK_LEN in
* the checksum set, using precalculated WEAK_SUM.
*
* If we don't find a match on the weak checksum, then we just give
* up. If we do find a weak match, then we proceed to calculate the
* strong checksum for the current block, and see if it will match
* anything.
*/
int
rs_search_for_block(rs_weak_sum_t weak_sum,
const rs_byte_t *inbuf,
size_t block_len,
rs_signature_t const *sig, rs_stats_t * stats,
rs_long_t * match_where)
{
/* Caller must have called rs_build_hash_table() by now */
if (!sig->tag_table)
rs_fatal("Must have called rs_build_hash_table() by now");
rs_strong_sum_t strong_sum;
int got_strong = 0;
int hash_tag = gettag(weak_sum);
rs_tag_table_entry_t *bucket = &(sig->tag_table[hash_tag]);
int l = bucket->l;
int r = bucket->r + 1;
int v = 1;
if (l == NULL_TAG)
return 0;
while (l < r) {
int m = (l + r) >> 1;
int i = sig->targets[m].i;
rs_block_sig_t *b = &(sig->block_sigs[i]);
v = (weak_sum > b->weak_sum) - (weak_sum < b->weak_sum); // v < 0 - weak_sum < b->weak_sum
// v == 0 - weak_sum == b->weak_sum
// v > 0 - weak_sum > b->weak_sum
if (v == 0) {
if (!got_strong) {
if(sig->magic == RS_BLAKE2_SIG_MAGIC) {
rs_calc_blake2_sum(inbuf, block_len, &strong_sum);
} else if (sig->magic == RS_MD4_SIG_MAGIC) {
rs_calc_md4_sum(inbuf, block_len, &strong_sum);
} else {
rs_error("Unknown signature algorithm - this is a BUG");
return 0; /* FIXME: Is this the best way to handle this? */
}
got_strong = 1;
}
v = memcmp(strong_sum, b->strong_sum, sig->strong_sum_len);
if (v == 0) {
l = m;
r = m;
break;
}
}
if (v > 0)
l = m + 1;
else
r = m;
}
if (l == r) {
int i = sig->targets[l].i;
rs_block_sig_t *b = &(sig->block_sigs[i]);
if (weak_sum != b->weak_sum)
return 0;
if (!got_strong) {
if(sig->magic == RS_BLAKE2_SIG_MAGIC) {
rs_calc_blake2_sum(inbuf, block_len, &strong_sum);
} else if (sig->magic == RS_MD4_SIG_MAGIC) {
rs_calc_md4_sum(inbuf, block_len, &strong_sum);
} else {
rs_error("Unknown signature algorithm - this is a BUG");
return 0; /* FIXME: Is this the best way to handle this? */
}
got_strong = 1;
}
v = memcmp(strong_sum, b->strong_sum, sig->strong_sum_len);
int token = b->i;
*match_where = (rs_long_t)(token - 1) * sig->block_len;
}
return !v;
}
/*
* cmd is one of:
* 'p': normal print
* 'h': just print headwords
* 'P': print raw
*/
void
pgwprintentry(Entry e, int cmd)
{
char *p, *pe;
int t;
long r, rprev, rlig;
Rune *transtab;
p = e.start;
pe = e.end;
transtab = normtab;
rprev = NONE;
changett(0, 0, 0);
curentry = e;
if(cmd == 'h')
outinhibit = 1;
while(p < pe) {
if(cmd == 'r') {
outchar(*p++);
continue;
}
r = transtab[(*p++)&0x7F];
if(r < NONE) {
/* Emit the rune, but buffer in case of ligature */
if(rprev != NONE)
outrune(rprev);
rprev = r;
} else if(r == SPCS) {
/* Start of special character name */
p = getspec(p, pe);
r = lookassoc(spectab, asize(spectab), spec);
if(r == -1) {
if(debug)
err("spec %ld %d %s",
e.doff, cursize, spec);
r = L'�';
}
if(r >= LIGS && r < LIGE) {
/* handle possible ligature */
rlig = liglookup(r, rprev);
if(rlig != NONE)
rprev = rlig; /* overwrite rprev */
else {
/* could print accent, but let's not */
if(rprev != NONE) outrune(rprev);
rprev = NONE;
}
} else if(r >= MULTI && r < MULTIE) {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
outrunes(multitab[r-MULTI]);
} else if(r == PAR) {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
outnl(1);
} else {
if(rprev != NONE) outrune(rprev);
rprev = r;
}
} else if(r == TAGS) {
/* Start of tag name */
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
p = gettag(p, pe);
t = lookassoc(tagtab, asize(tagtab), tag);
if(t == -1) {
if(debug)
err("tag %ld %d %s",
e.doff, cursize, tag);
continue;
}
switch(t) {
case Hw:
if(cmd == 'h') {
if(!tagstarts)
outchar(' ');
outinhibit = !tagstarts;
}
break;
case Sn:
if(tagstarts) {
outnl(2);
}
break;
case P:
outnl(tagstarts);
break;
case Col:
case Br:
case Blockquote:
if(tagstarts)
outnl(1);
break;
case U:
outchar('/');
}
}
}
if(cmd == 'h') {
outinhibit = 0;
outnl(0);
}
}
static void setreturn(int32 id, const char *name) {
int32 tag = gettag(IOTAG);
setfile(id, name, tag);
lua_pushusertag(id, tag);
}
/* helper function for parser */
void set_optdepends() {
#ifdef DEBUG
printf("tag '%u' is set optional depends\n", gettag());
#endif
parser_state.req=optdepends;
}
static void setreturn (FILE *f, char *name)
{
int tag = gettag(IOTAG);
setfile(f, name, tag);
lua_pushusertag(f, tag);
}
/* helper function for parser */
void set_mandatory() {
#ifdef DEBUG
printf("tag '%u' is mandatory\n", gettag());
#endif
parser_state.req=mandatory;
}
BOOL WINAPI mp4GetTag(MAP_PLUGIN_FILETAG* pTag)
{
return gettag(pTag) ? TRUE : FALSE;
}
int main(int argc, char *argv[])
{
pcap_t *handle;/* Session handle */
const char *opt_chdir;/* directory to write dump */
char *ifname;/* interface to sniff on */
char *fname;/* pcap file to read on */
char errbuf[PCAP_ERRBUF_SIZE];/* Error string */
struct bpf_program fp;/* The compiled filter */
char filter_exp[] = "udp";/* The filter expression */
bpf_u_int32 mask;/* Our netmask */
bpf_u_int32 net;/* Our IP */
struct pcap_pkthdr *pkt_header; /* The header that pcap gives us */
const u_char *pkt_data; /* The actual packet */
unsigned long last_cleanup=0;
int res;
int offset_to_ip=0;
int opt_fork=1;
int opt_promisc=1;
int opt_packetbuffered=0;
int opt_t38only=0;
int opt_rtpsave=RTPSAVE_RTP_RTCP;
int verbosity=0;
bool number_filter_matched=false;
#ifdef USE_REGEXP
regex_t number_filter;
number_filter.allocated=0;
#else
char number_filter[128];
number_filter[0]=0;
#endif
ifname=NULL;
fname=NULL;
opt_chdir="/var/spool/pcapsipdump";
while(1) {
char c;
c = getopt (argc, argv, "i:r:d:v:n:R:fpUt");
if (c == -1)
break;
switch (c) {
case 'i':
ifname=optarg;
break;
case 'v':
verbosity=atoi(optarg);
break;
case 'n':
#ifdef USE_REGEXP
regcomp(&number_filter,optarg,0);
#else
strcpy(number_filter,optarg);
#endif
break;
case 'R':
if (strcasecmp(optarg,"none")==0){
opt_rtpsave=RTPSAVE_NONE;
}else if (strcasecmp(optarg,"rtpevent")==0){
opt_rtpsave=RTPSAVE_RTPEVENT;
}else if (strcasecmp(optarg,"t38")==0){
opt_t38only=1;
}else if (strcasecmp(optarg,"all")==0 ||
strcasecmp(optarg,"rtp+rtcp")==0){
opt_rtpsave=RTPSAVE_RTP_RTCP;
}else if (strcasecmp(optarg,"rtp")==0){
opt_rtpsave=RTPSAVE_RTP;
}else{
printf("Unrecognized RTP filter specification: '%s'\n",optarg);
return 1;
}
break;
case 't':
opt_t38only=1;
break;
case 'r':
fname=optarg;
break;
case 'd':
opt_chdir=optarg;
break;
case 'f':
opt_fork=0;
break;
case 'p':
opt_promisc=0;
break;
case 'U':
opt_packetbuffered=1;
break;
}
}
// allow interface to be specified without '-i' option - for sake of compatibility
if (optind < argc) {
ifname = argv[optind];
}
if ((fname==NULL)&&(ifname==NULL)){
printf( "pcapsipdump version %s\n"
"Usage: pcapsipdump [-fpU] [-i <interface>] [-r <file>] [-d <working directory>] [-v level] [-R filter]\n"
" -f Do not fork or detach from controlling terminal.\n"
" -p Do not put the interface into promiscuous mode.\n"
" -R RTP filter. Possible values: 'rtp+rtcp' (default), 'rtp', 'rtpevent', 't38', or 'none'.\n"
" -U Make .pcap files writing 'packet-buffered' - slower method,\n"
" but you can use partitially written file anytime, it will be consistent.\n"
" -v Set verbosity level (higher is more verbose).\n"
" -n Number-filter. Only calls to/from specified number will be recorded\n"
#ifdef USE_REGEXP
" Argument is regular expression. See 'man 7 regex' for details\n"
#endif
" -t T.38-filter. Only calls, containing T.38 payload indicated in SDP will be recorded\n"
,PCAPSIPDUMP_VERSION);
return 1;
}
ct = new calltable;
if (opt_t38only){
ct->erase_non_t38=1;
}
signal(SIGINT,sigint_handler);
signal(SIGTERM,sigterm_handler);
if (ifname){
printf("Capturing on interface: %s\n", ifname);
/* Find the properties for interface */
if (pcap_lookupnet(ifname, &net, &mask, errbuf) == -1) {
fprintf(stderr, "Couldn't get netmask for interface %s: %s\n", ifname, errbuf);
net = 0;
mask = 0;
}
handle = pcap_open_live(ifname, 1600, opt_promisc, 1000, errbuf);
if (handle == NULL) {
fprintf(stderr, "Couldn't open interface '%s': %s\n", ifname, errbuf);
return(2);
}
}else{
printf("Reading file: %s\n", fname);
net = 0;
mask = 0;
handle = pcap_open_offline(fname, errbuf);
if (handle == NULL) {
fprintf(stderr, "Couldn't open pcap file '%s': %s\n", ifname, errbuf);
return(2);
}
}
chdir(opt_chdir);
/* Compile and apply the filter */
if (pcap_compile(handle, &fp, filter_exp, 0, net) == -1) {
fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
if (pcap_setfilter(handle, &fp) == -1) {
fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
return(2);
}
if (opt_fork){
// daemonize
if (fork()) exit(0);
}
{
int dlt=pcap_datalink(handle);
switch (dlt){
case DLT_EN10MB :
offset_to_ip=sizeof(struct ether_header);
break;
case DLT_LINUX_SLL :
offset_to_ip=16;
break;
case DLT_RAW :
offset_to_ip=0;
break;
default : {
printf("Unknown interface type (%d).\n",dlt);
return 3;
}
}
}
/* Retrieve the packets */
while((res = pcap_next_ex( handle, &pkt_header, &pkt_data)) >= 0){
{
struct iphdr *header_ip;
struct udphdr *header_udp;
char *data;
char *s;
char str1[1024],str2[1024];
unsigned long datalen;
unsigned long l;
int idx;
if(res == 0)
/* Timeout elapsed */
continue;
if (pkt_header->ts.tv_sec-last_cleanup>15){
if (last_cleanup>=0){
ct->do_cleanup(pkt_header->ts.tv_sec);
}
last_cleanup=pkt_header->ts.tv_sec;
}
header_ip=(iphdr *)((char*)pkt_data+offset_to_ip);
if (header_ip->protocol==17){//UPPROTO_UDP=17
int idx_leg=0;
int idx_rtp=0;
int save_this_rtp_packet=0;
int is_rtcp=0;
uint16_t rtp_port_mask=0xffff;
header_udp=(udphdr *)((char*)header_ip+sizeof(*header_ip));
data=(char *)header_udp+sizeof(*header_udp);
datalen=pkt_header->len-((unsigned long)data-(unsigned long)pkt_data);
if (opt_rtpsave==RTPSAVE_RTP){
save_this_rtp_packet=1;
}else if (opt_rtpsave==RTPSAVE_RTP_RTCP){
save_this_rtp_packet=1;
rtp_port_mask=0xfffe;
is_rtcp=(htons(header_udp->source) & 1) && (htons(header_udp->dest) & 1);
}else if (opt_rtpsave==RTPSAVE_RTPEVENT &&
datalen==18 && (data[0]&0xff) == 0x80 && (data[1]&0x7d) == 0x65){
save_this_rtp_packet=1;
}else{
save_this_rtp_packet=0;
}
if (save_this_rtp_packet &&
ct->find_ip_port_ssrc(
header_ip->daddr,htons(header_udp->dest) & rtp_port_mask,
get_ssrc(data,is_rtcp),
&idx_leg,&idx_rtp)){
if (ct->table[idx_leg].f_pcap!=NULL) {
ct->table[idx_leg].last_packet_time=pkt_header->ts.tv_sec;
pcap_dump((u_char *)ct->table[idx_leg].f_pcap,pkt_header,pkt_data);
if (opt_packetbuffered) {pcap_dump_flush(ct->table[idx_leg].f_pcap);}
}
}else if (save_this_rtp_packet &&
ct->find_ip_port_ssrc(
header_ip->saddr,htons(header_udp->source) & rtp_port_mask,
get_ssrc(data,is_rtcp),
&idx_leg,&idx_rtp)){
if (ct->table[idx_leg].f_pcap!=NULL) {
ct->table[idx_leg].last_packet_time=pkt_header->ts.tv_sec;
pcap_dump((u_char *)ct->table[idx_leg].f_pcap,pkt_header,pkt_data);
if (opt_packetbuffered) {pcap_dump_flush(ct->table[idx_leg].f_pcap);}
}
}else if (htons(header_udp->source)==5060||
htons(header_udp->dest)==5060){
char caller[256];
char called[256];
char sip_method[256];
//figure out method
memcpy(sip_method,data,sizeof(sip_method)-1);
sip_method[sizeof(sip_method)-1]=' ';
if (strchr(sip_method,' ')!=NULL){
*strchr(sip_method,' ')='\0';
}else{
sip_method[0]='\0';
if (verbosity>=2){
printf("Empty SIP method!\n");
}
}
data[datalen]=0;
get_sip_peername(data,datalen,"From:",caller,sizeof(caller));
get_sip_peername(data,datalen,"To:",called,sizeof(called));
s=gettag(data,datalen,"Call-ID:",&l);
number_filter_matched=false;
#ifdef USE_REGEXP
{
regmatch_t pmatch[1];
if ((number_filter.allocated==0) ||
(regexec(&number_filter, caller, 1, pmatch, 0)==0) ||
(regexec(&number_filter, called, 1, pmatch, 0)==0)) {
number_filter_matched=true;
}
}
#else
if (number_filter[0]==0||(strcmp(number_filter,caller)==0)||(strcmp(number_filter,called)==0)) {
number_filter_matched=true;
}
#endif
if (s!=NULL && ((idx=ct->find_by_call_id(s,l))<0) && number_filter_matched){
if ((idx=ct->add(s,l,pkt_header->ts.tv_sec))<0){
printf("Too many simultaneous calls. Ran out of call table space!\n");
}else{
if ((strcmp(sip_method,"INVITE")==0)||(strcmp(sip_method,"OPTIONS")==0)||(strcmp(sip_method,"REGISTER")==0)){
struct tm *t;
t=localtime(&pkt_header->ts.tv_sec);
sprintf(str2,"%04d%02d%02d",
t->tm_year+1900,t->tm_mon+1,t->tm_mday);
mkdir(str2,0700);
sprintf(str2,"%04d%02d%02d/%02d",
t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour);
mkdir(str2,0700);
sprintf(str2,"%04d%02d%02d/%02d/%04d%02d%02d-%02d%02d%02d-%s-%s",
t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,
t->tm_year+1900,t->tm_mon+1,t->tm_mday,t->tm_hour,t->tm_min,t->tm_sec,caller,called);
memcpy(str1,s,l);
str1[l]='\0';
strcat(str2,"-");
strcat(str2,str1);
strcat(str2,".raw");
ct->table[idx].f=NULL;
str1[l]='\0';
*strstr(str2,".raw")='\0';
strcat(str2,".pcap");
ct->table[idx].f_pcap=pcap_dump_open(handle,str2);
strncpy(ct->table[idx].fn_pcap,str2,sizeof(ct->table[idx].fn_pcap));
}else{
if (verbosity>=2){
printf("Unknown SIP method:'%s'!\n",sip_method);
}
ct->table[idx].f=NULL;
ct->table[idx].f_pcap=NULL;
}
}
}
// idx holds a valid pointer to open leg at this point
if (strcmp(sip_method,"BYE")==0){
ct->table[idx].had_bye=1;
}
s=gettag(data,datalen,"Content-Type:",&l);
if(idx>=0 && l>0 && strncasecmp(s,"application/sdp",l)==0 && strstr(data,"\r\n\r\n")!=NULL){
in_addr_t tmp_addr;
unsigned short tmp_port;
if (!get_ip_port_from_sdp(strstr(data,"\r\n\r\n")+1,&tmp_addr,&tmp_port)){
ct->add_ip_port(idx,tmp_addr,tmp_port);
}else{
if (verbosity>=2){
printf("Can't get ip/port from SDP:\n%s\n\n",strstr(data,"\r\n\r\n")+1);
}
}
if (opt_t38only && memmem(data,datalen,"udptl t38",9)!=NULL){
ct->table[idx].had_t38=1;
}
}
if (ct->table[idx].f_pcap!=NULL){
pcap_dump((u_char *)ct->table[idx].f_pcap,pkt_header,pkt_data);
if (opt_packetbuffered) {pcap_dump_flush(ct->table[idx].f_pcap);}
}
}else{
if (verbosity>=3){
char st1[16];
char st2[16];
struct in_addr in;
in.s_addr=header_ip->saddr;
strcpy(st1,inet_ntoa(in));
in.s_addr=header_ip->daddr;
strcpy(st2,inet_ntoa(in));
printf ("Skipping udp packet %s:%d->%s:%d\n",st1,htons(header_udp->source),st2,htons(header_udp->dest));
}
}
}
}
}
/* flush / close files */
ct->do_cleanup(1<<31);
/* And close the session */
pcap_close(handle);
return(0);
}
void write_file(iface_t *ifa)
{
struct if_file *ifc = (struct if_file *) ifa->info;
senblk_t *sptr;
int usereturn=flag_test(ifa,F_NOCR)?0:1;
int data=0;
int cnt=1;
struct iovec iov[2];
/* ifc->fd will only be < 0 if we're opening a FIFO.
*/
if (ifc->fd < 0) {
if ((ifc->fd=open(ifc->filename,O_WRONLY)) < 0) {
logerr(errno,"Failed to open FIFO %s for writing\n",ifc->filename);
iface_thread_exit(errno);
}
if ((ifa->q =init_q(ifc->qsize)) == NULL) {
logerr(errno,"Could not create queue for FIFO %s",ifc->filename);
iface_thread_exit(errno);
}
}
if (ifa->tagflags) {
if ((iov[0].iov_base=malloc(TAGMAX)) == NULL) {
logerr(errno,"Disabing tag output on interface id %u (%s)",
ifa->id,(ifa->name)?ifa->name:"unlabelled");
ifa->tagflags=0;
} else {
cnt=2;
data=1;
}
}
for(;;) {
if ((sptr = next_senblk(ifa->q)) == NULL) {
break;
}
if (senfilter(sptr,ifa->ofilter)) {
senblk_free(sptr,ifa->q);
continue;
}
if (!usereturn) {
sptr->data[sptr->len-2] = '\n';
sptr->len--;
}
if (ifa->tagflags)
if ((iov[0].iov_len = gettag(ifa,iov[0].iov_base,sptr)) == 0) {
logerr(errno,"Disabing tag output on interface id %u (%s)",
ifa->id,(ifa->name)?ifa->name:"unlabelled");
ifa->tagflags=0;
cnt=1;
data=0;
free(iov[0].iov_base);
}
iov[data].iov_base=sptr->data;
iov[data].iov_len=sptr->len;
if (writev(ifc->fd,iov,cnt) <0) {
if (!(flag_test(ifa,F_PERSIST) && errno == EPIPE) )
break;
if ((ifc->fd=open(ifc->filename,O_WRONLY)) < 0)
break;
}
senblk_free(sptr,ifa->q);
}
if (cnt == 2)
free(iov[0].iov_base);
iface_thread_exit(errno);
}
// Call this to get the tokens.
// The number of returned tokens is returned in *plen.
Token*
_gettoks(uchar* data, int datalen, int chset, int mtype, int* plen)
{
TokenSource* ts;
Token* a;
int alen;
int ai;
int starti;
int c;
int tag;
if(!lexinited)
lexinit();
ts = newtokensource(data, datalen, chset, mtype);
if(dbglex)
fprint(2, "_gettoks starts, ts.i=%d, ts.edata=%d\n", ts->i, ts->edata);
alen = 0;
ai = 0;
a = 0;
if(ts->mtype == TextHtml) {
for(;;) {
if(alen - ai < ToksChunk/32) {
alen += ToksChunk;
a = erealloc(a, alen*sizeof *a);
}
starti = ts->i;
c = getchar(ts);
if(c < 0)
break;
if(c == '<') {
tag = gettag(ts, starti, a, &ai);
if(tag == Tscript || tag == Tstyle) {
// special rules for getting Data after....
starti = ts->i;
c = getchar(ts);
tag = getscriptdata(ts, c, starti, a, &ai, tag);
}
}
else
tag = getdata(ts, c, starti, a, &ai);
if(tag == -1)
break;
else if(dbglex > 1 && tag != Comment)
fprint(2, "lex: got token %T\n", &a[ai-1]);
}
}
else {
// plain text (non-html) tokens
for(;;) {
if(alen - ai < ToksChunk/32) {
alen += ToksChunk;
a = erealloc(a, alen*sizeof *a);
}
tag = getplaindata(ts, a, &ai);
if(tag == -1)
break;
if(dbglex > 1)
fprint(2, "lex: got token %T\n", &a[ai]);
}
}
free(ts);
if(dbglex)
fprint(2, "lex: returning %d tokens\n", ai);
*plen = ai;
if(ai == 0){
free(a);
a = 0;
}
return a;
}
// The rules for lexing scripts are different (ugh).
// Gather up everything until see an "</" tagnames[tok] ">"
static int
getscriptdata(TokenSource* ts, int firstc, int starti, Token* a, int* pai, int findtag)
{
Rune* s;
int j;
int tstarti;
int savei;
int c;
int tag;
int done;
Token* tok;
Rune buf[BIGBUFSIZE];
s = nil;
j = 0;
tstarti = starti;
c = firstc;
done = 0;
while(c >= 0) {
if(c == '<') {
// other browsers ignore stuff to end of line after <!
savei = ts->i;
c = getchar(ts);
if(c == '!') {
if(comment(ts) == -1)
break;
if(c == '\r')
c = getchar(ts);
if(c == '\n')
c = getchar(ts);
}
else if(c >= 0) {
backup(ts, savei);
tag = gettag(ts, tstarti, a, pai);
if(tag == -1)
break;
if(tag != Comment)
(*pai)--;
backup(ts, tstarti);
if(tag == findtag + RBRA) {
done = 1;
break;
}
// here tag was not the one we were looking for, so take as regular data
c = getchar(ts);
}
}
if(c < 0)
break;
if(c != 0) {
buf[j++] = c;
if(j == nelem(buf)-1) {
s = buftostr(s, buf, j);
j = 0;
}
}
tstarti = ts->i;
c = getchar(ts);
}
if(done || ts->i == ts->edata) {
s = buftostr(s, buf, j);
tok = &a[(*pai)++];
tok->tag = Data;
tok->text = s;
tok->attr = nil;
tok->starti = starti;
return Data;
}
free(s);
backup(ts, starti);
return -1;
}
/* helper function for parser */
void set_optional() {
#ifdef DEBUG
printf("tag '%u' is optional\n", gettag());
#endif
parser_state.req=optional;
}
void
pcollprintentry(Entry e, int cmd)
{
char *p, *pe;
long r, rprev, t, rlig;
int saveoi;
Rune *transtab;
p = e.start;
pe = e.end;
transtab = normtab;
rprev = NONE;
changett(0, 0, 0);
curentry = e;
saveoi = 0;
if(cmd == 'h')
outinhibit = 1;
while(p < pe) {
if(cmd == 'r') {
outchar(*p++);
continue;
}
r = transtab[(*p++)&0x7F];
if(r < NONE) {
/* Emit the rune, but buffer in case of ligature */
if(rprev != NONE)
outrune(rprev);
rprev = r;
} else if(r == TAGS) {
p = gettag(p, pe);
t = lookassoc(tagtab, asize(tagtab), tag);
if(t == -1) {
if(debug && !outinhibit)
err("tag %ld %d %s",
e.doff, cursize, tag);
continue;
}
if(t < NONE) {
if(rprev != NONE)
outrune(rprev);
rprev = t;
} else if(t >= LIGS && t < LIGE) {
/* handle possible ligature */
rlig = liglookup(t, rprev);
if(rlig != NONE)
rprev = rlig; /* overwrite rprev */
else {
/* could print accent, but let's not */
if(rprev != NONE) outrune(rprev);
rprev = NONE;
}
} else if(t >= MULTI && t < MULTIE) {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
outrunes(multitab[t-MULTI]);
} else {
if(rprev != NONE) {
outrune(rprev);
rprev = NONE;
}
switch(t){
case H:
if(cmd == 'h')
outinhibit = 0;
else
outnl(0);
break;
case X:
if(cmd == 'h')
outinhibit = 1;
else
outchars(". ");
break;
case Ps:
/* don't know enough of pron. key yet */
saveoi = outinhibit;
outinhibit = 1;
break;
case Pe:
outinhibit = saveoi;
break;
}
}
}
}
if(cmd == 'h')
outinhibit = 0;
outnl(0);
}
/* helper function for parser */
void set_ifdepends() {
#ifdef DEBUG
printf("tag '%u' is set if depends\n", gettag());
#endif
parser_state.req=ifdepends;
}
static void closefile(const char *name) {
LuaFile *f = getfile(name);
f->close();
lua_pushobject(lua_getglobal(name));
lua_settag(gettag(CLOSEDTAG));
}
Packet*
_vtrpc(VtConn *z, Packet *p, VtFcall *tx)
{
int i;
uchar tag, buf[2], *top;
Rwait *r, *rr;
/* must malloc because stack could be private */
r = vtmallocz(sizeof(Rwait));
qlock(&z->lk);
r->r.l = &z->lk;
tag = gettag(z, r);
if(tx){
/* vtfcallrpc can't print packet because it doesn't have tag */
tx->tag = tag;
if(chattyventi)
fprint(2, "%s -> %F\n", argv0, tx);
}
/* slam tag into packet */
top = packetpeek(p, buf, 0, 2);
if(top == nil){
packetfree(p);
return nil;
}
if(top == buf){
werrstr("first two bytes must be in same packet fragment");
packetfree(p);
vtfree(r);
return nil;
}
top[1] = tag;
qunlock(&z->lk);
if(vtsend(z, p) < 0){
vtfree(r);
return nil;
}
qlock(&z->lk);
/* wait for the muxer to give us our packet */
r->sleeping = 1;
z->nsleep++;
while(z->muxer && !r->done)
rsleep(&r->r);
z->nsleep--;
r->sleeping = 0;
/* if not done, there's no muxer: start muxing */
if(!r->done){
if(z->muxer)
abort();
z->muxer = 1;
while(!r->done){
qunlock(&z->lk);
if((p = vtrecv(z)) == nil){
werrstr("unexpected eof on venti connection");
z->muxer = 0;
vtfree(r);
return nil;
}
qlock(&z->lk);
muxrpc(z, p);
}
z->muxer = 0;
/* if there is anyone else sleeping, wake first unfinished to mux */
if(z->nsleep)
for(i=0; i<256; i++){
rr = z->wait[i];
if(rr && rr->sleeping && !rr->done){
rwakeup(&rr->r);
break;
}
}
}
p = r->p;
puttag(z, r, tag);
vtfree(r);
qunlock(&z->lk);
return p;
}
