gets <getopt.h>, so we get the optarg global.
svn path=/trunk/; revision=51350
static void
-afpstat_init(const char *optarg, void* userdata _U_)
+afpstat_init(const char *opt_arg, void* userdata _U_)
{
afpstat_t *ss;
guint32 i;
const char *filter=NULL;
GString *error_string;
- if(!strncmp(optarg,"afp,srt,",8)){
- filter=optarg+8;
+ if(!strncmp(opt_arg,"afp,srt,",8)){
+ filter=opt_arg+8;
} else {
filter=NULL;
}
static void
-ansi_a_stat_init(const char *optarg _U_, void* userdata _U_)
+ansi_a_stat_init(const char *opt_arg _U_, void* userdata _U_)
{
ansi_a_stat_t *stat_p;
GString *err_p;
/* When called, this function will create a new instance of tap-boopstat.
*/
static void
-dhcpstat_init(const char *optarg, void* userdata _U_)
+dhcpstat_init(const char *opt_arg, void* userdata _U_)
{
dhcpstat_t *sp;
const char *filter=NULL;
GString *error_string;
- if (!strncmp (optarg, "bootp,stat,", 11)){
- filter=optarg+11;
+ if (!strncmp (opt_arg, "bootp,stat,", 11)){
+ filter=opt_arg+11;
} else {
filter=NULL;
}
printf("------------------------------------------\n");
}
-static void camelcounter_init(const char *optarg, void* userdata _U_)
+static void camelcounter_init(const char *opt_arg, void* userdata _U_)
{
struct camelcounter_t *p_camelcounter;
GString *error_string;
p_camelcounter = g_new(struct camelcounter_t,1);
- if(!strncmp(optarg,"camel,counter,",13)){
- p_camelcounter->filter=g_strdup(optarg+13);
+ if(!strncmp(opt_arg,"camel,counter,",13)){
+ p_camelcounter->filter=g_strdup(opt_arg+13);
} else {
p_camelcounter->filter=NULL;
}
printf("\n");
}
-static void camelsrt_init(const char *optarg, void* userdata _U_)
+static void camelsrt_init(const char *opt_arg, void* userdata _U_)
{
struct camelsrt_t *p_camelsrt;
GString *error_string;
p_camelsrt = g_new(struct camelsrt_t,1);
- if(!strncmp(optarg,"camel,srt,",9)){
- p_camelsrt->filter=g_strdup(optarg+9);
+ if(!strncmp(opt_arg,"camel,srt,",9)){
+ p_camelsrt->filter=g_strdup(opt_arg+9);
} else {
p_camelsrt->filter=NULL;
}
* new instance for the compare tap.
*/
static void
-comparestat_init(const char *optarg, void* userdata _U_)
+comparestat_init(const char *opt_arg, void* userdata _U_)
{
comparestat_t *cs;
const char *filter=NULL;
gint start, stop,ttl, order, pos=0;
gdouble variance;
- if(sscanf(optarg,"compare,%d,%d,%d,%d,%lf%n",&start, &stop, &ttl, &order, &variance, &pos)==5){
+ if(sscanf(opt_arg,"compare,%d,%d,%d,%d,%lf%n",&start, &stop, &ttl, &order, &variance, &pos)==5){
if(pos){
- if(*(optarg+pos)==',')
- filter=optarg+pos+1;
+ if(*(opt_arg+pos)==',')
+ filter=opt_arg+pos+1;
else
- filter=optarg+pos;
+ filter=opt_arg+pos;
} else {
filter=NULL;
}
static void
-dcerpcstat_init(const char *optarg, void* userdata _U_)
+dcerpcstat_init(const char *opt_arg, void* userdata _U_)
{
rpcstat_t *rs;
guint32 i, max_procs;
* report aggregate statistics for all minor version numbers
* if it's omitted?
*/
- if(sscanf(optarg,
+ if(sscanf(opt_arg,
"dcerpc,srt,%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x,%d.%d%n",
&d1,&d2,&d3,&d40,&d41,&d42,&d43,&d44,&d45,&d46,&d47,
&major,&minor,&pos)==13){
uuid.Data4[6]=d46;
uuid.Data4[7]=d47;
if(pos){
- filter=optarg+pos;
+ filter=opt_arg+pos;
} else {
filter=NULL;
}
static void
-diameteravp_init(const char *optarg, void* userdata _U_)
+diameteravp_init(const char *opt_arg, void* userdata _U_)
{
diameteravp_t *ds;
gchar* field=NULL;
filter=g_string_new("diameter");
/* Split command line options. */
- tokens = g_strsplit(optarg,",", 1024);
+ tokens = g_strsplit(opt_arg,",", 1024);
opt_count=0;
while (tokens[opt_count])
opt_count++;
}
/* Create a new expert stats struct */
-static void expert_stat_init(const char *optarg, void *userdata _U_)
+static void expert_stat_init(const char *opt_arg, void *userdata _U_)
{
const char *args = NULL;
const char *filter = NULL;
int n;
/* Check for args. */
- if (strncmp(optarg, "expert", 6) == 0) {
+ if (strncmp(opt_arg, "expert", 6) == 0) {
/* Skip those characters */
- args = optarg + 6;
+ args = opt_arg + 6;
}
else {
/* No args. Will show all reports, with no filter */
static gboolean
followArgStrncmp(
- const char ** optargp,
+ const char ** opt_argp,
const char * strp
)
{
int len = (guint32)strlen(strp);
- if (strncmp(*optargp, strp, len) == 0)
+ if (strncmp(*opt_argp, strp, len) == 0)
{
- *optargp += len;
+ *opt_argp += len;
return TRUE;
}
return FALSE;
static void
followArgMode(
- const char ** optargp,
+ const char ** opt_argp,
follow_t * fp
)
{
- if (followArgStrncmp(optargp, STR_HEX))
+ if (followArgStrncmp(opt_argp, STR_HEX))
{
fp->mode = mode_HEX;
}
- else if (followArgStrncmp(optargp, STR_ASCII))
+ else if (followArgStrncmp(opt_argp, STR_ASCII))
{
fp->mode = mode_ASCII;
}
- else if (followArgStrncmp(optargp, STR_RAW))
+ else if (followArgStrncmp(opt_argp, STR_RAW))
{
fp->mode = mode_RAW;
}
static void
followArgFilter(
- const char ** optargp,
+ const char ** opt_argp,
follow_t * fp
)
{
unsigned int ii;
char addr[ADDR_LEN];
- if (sscanf(*optargp, ",%u%n", &fp->index, &len) == 1 &&
- ((*optargp)[len] == 0 || (*optargp)[len] == ','))
+ if (sscanf(*opt_argp, ",%u%n", &fp->index, &len) == 1 &&
+ ((*opt_argp)[len] == 0 || (*opt_argp)[len] == ','))
{
- *optargp += len;
+ *opt_argp += len;
}
else
{
for (ii = 0; ii < sizeof fp->addr/sizeof *fp->addr; ii++)
{
- if ((sscanf(*optargp, ADDRv6_FMT, addr, &fp->port[ii], &len) != 2 &&
- sscanf(*optargp, ADDRv4_FMT, addr, &fp->port[ii], &len) != 2) ||
+ if ((sscanf(*opt_argp, ADDRv6_FMT, addr, &fp->port[ii], &len) != 2 &&
+ sscanf(*opt_argp, ADDRv4_FMT, addr, &fp->port[ii], &len) != 2) ||
fp->port[ii] <= 0 || fp->port[ii] > G_MAXUINT16)
{
followExit("Invalid address:port pair.");
SET_ADDRESS(&fp->addr[ii], AT_IPv4, 4, fp->addrBuf[ii]);
}
- *optargp += len;
+ *opt_argp += len;
}
if (fp->addr[0].type != fp->addr[1].type)
static void
followArgRange(
- const char ** optargp,
+ const char ** opt_argp,
follow_t * fp
)
{
int len;
- if (**optargp == 0)
+ if (**opt_argp == 0)
{
fp->chunkMin = 1;
fp->chunkMax = G_MAXUINT32;
}
else
{
- if (sscanf(*optargp, ",%u-%u%n", &fp->chunkMin, &fp->chunkMax, &len) == 2)
+ if (sscanf(*opt_argp, ",%u-%u%n", &fp->chunkMin, &fp->chunkMax, &len) == 2)
{
- *optargp += len;
+ *opt_argp += len;
}
- else if (sscanf(*optargp, ",%u%n", &fp->chunkMin, &len) == 1)
+ else if (sscanf(*opt_argp, ",%u%n", &fp->chunkMin, &len) == 1)
{
fp->chunkMax = fp->chunkMin;
- *optargp += len;
+ *opt_argp += len;
}
else
{
static void
followArgDone(
- const char * optargp
+ const char * opt_argp
)
{
- if (*optargp != 0)
+ if (*opt_argp != 0)
{
followExit("Invalid parameter.");
}
static void
followTcp(
- const char * optargp,
+ const char * opt_argp,
void * userdata _U_
)
{
follow_t * fp;
GString * errp;
- optargp += strlen(STR_FOLLOW_TCP);
+ opt_argp += strlen(STR_FOLLOW_TCP);
fp = followAlloc(type_TCP);
- followArgMode(&optargp, fp);
- followArgFilter(&optargp, fp);
- followArgRange(&optargp, fp);
- followArgDone(optargp);
+ followArgMode(&opt_argp, fp);
+ followArgFilter(&opt_argp, fp);
+ followArgRange(&opt_argp, fp);
+ followArgDone(opt_argp);
reset_tcp_reassembly();
if (fp->index != G_MAXUINT32)
static void
followUdp(
- const char * optargp,
+ const char * opt_argp,
void * userdata _U_
)
{
follow_t * fp;
GString * errp;
- optargp += strlen(STR_FOLLOW_UDP);
+ opt_argp += strlen(STR_FOLLOW_UDP);
fp = followAlloc(type_UDP);
- followArgMode(&optargp, fp);
- followArgFilter(&optargp, fp);
- followArgRange(&optargp, fp);
- followArgDone(optargp);
+ followArgMode(&opt_argp, fp);
+ followArgFilter(&opt_argp, fp);
+ followArgRange(&opt_argp, fp);
+ followArgDone(opt_argp);
if (fp->index != G_MAXUINT32)
{
static void
followSsl(
- const char * optargp,
+ const char * opt_argp,
void * userdata _U_
)
{
follow_t * fp;
GString * errp;
- optargp += strlen(STR_FOLLOW_SSL);
+ opt_argp += strlen(STR_FOLLOW_SSL);
fp = followAlloc(type_SSL);
- followArgMode(&optargp, fp);
- followArgFilter(&optargp, fp);
- followArgRange(&optargp, fp);
- followArgDone(optargp);
+ followArgMode(&opt_argp, fp);
+ followArgFilter(&opt_argp, fp);
+ followArgRange(&opt_argp, fp);
+ followArgDone(opt_argp);
if (fp->index == G_MAXUINT32)
{
} menu_cb_t;
-static void init_funnel_cmd(const char *optarg, void* data ) {
- gchar** args = g_strsplit(optarg,",",0);
+static void init_funnel_cmd(const char *opt_arg, void* data ) {
+ gchar** args = g_strsplit(opt_arg,",",0);
gchar** arg;
menu_cb_t* mcb = data;
static void
-gsm_a_stat_init(const char *optarg _U_,void* userdata _U_)
+gsm_a_stat_init(const char *opt_arg _U_,void* userdata _U_)
{
gsm_a_stat_t *stat_p;
GString *err_p;
static void
-h225counter_init(const char *optarg, void* userdata _U_)
+h225counter_init(const char *opt_arg, void* userdata _U_)
{
h225counter_t *hs;
GString *error_string;
hs = g_new(h225counter_t,1);
- if(!strncmp(optarg,"h225,counter,",13)){
- hs->filter=g_strdup(optarg+13);
+ if(!strncmp(opt_arg,"h225,counter,",13)){
+ hs->filter=g_strdup(opt_arg+13);
} else {
hs->filter=NULL;
}
static void
-h225rassrt_init(const char *optarg, void* userdata _U_)
+h225rassrt_init(const char *opt_arg, void* userdata _U_)
{
h225rassrt_t *hs;
GString *error_string;
hs = g_new(h225rassrt_t,1);
- if(!strncmp(optarg,"h225,srt,",9)){
- hs->filter=g_strdup(optarg+9);
+ if(!strncmp(opt_arg,"h225,srt,",9)){
+ hs->filter=g_strdup(opt_arg+9);
} else {
hs->filter=NULL;
}
static void
-hosts_init(const char *optarg, void* userdata _U_)
+hosts_init(const char *opt_arg, void* userdata _U_)
{
GString *error_string;
gchar **tokens;
dump_v4 = FALSE;
dump_v6 = FALSE;
- if(strcmp(TAP_NAME, optarg)==0) {
+ if(strcmp(TAP_NAME, opt_arg)==0) {
/* No arguments; dump everything */
dump_v4 = TRUE;
dump_v6 = TRUE;
} else {
- tokens = g_strsplit(optarg,",", 0);
+ tokens = g_strsplit(opt_arg,",", 0);
opt_count=0;
while (tokens[opt_count]) {
if (strcmp("ipv4", tokens[opt_count]) == 0) {
/* When called, this function will create a new instance of gtk_httpstat.
*/
static void
-gtk_httpstat_init(const char *optarg,void* userdata _U_)
+gtk_httpstat_init(const char *opt_arg,void* userdata _U_)
{
httpstat_t *sp;
const char *filter=NULL;
GString *error_string;
- if (!strncmp (optarg, "http,stat,", 10)){
- filter=optarg+10;
+ if (!strncmp (opt_arg, "http,stat,", 10)){
+ filter=opt_arg+10;
} else {
filter=NULL;
}
* instance for the icmp tap.
*/
static void
-icmpstat_init(const char *optarg, void* userdata _U_)
+icmpstat_init(const char *opt_arg, void* userdata _U_)
{
icmpstat_t *icmpstat;
const char *filter = NULL;
GString *error_string;
- if (strstr(optarg, "icmp,srt,"))
- filter = optarg + strlen("icmp,srt,");
+ if (strstr(opt_arg, "icmp,srt,"))
+ filter = opt_arg + strlen("icmp,srt,");
icmpstat = (icmpstat_t *)g_try_malloc(sizeof(icmpstat_t));
if (icmpstat == NULL) {
* instance for the icmpv6 tap.
*/
static void
-icmpv6stat_init(const char *optarg, void* userdata _U_)
+icmpv6stat_init(const char *opt_arg, void* userdata _U_)
{
icmpv6stat_t *icmpv6stat;
const char *filter = NULL;
GString *error_string;
- if (strstr(optarg, "icmpv6,srt,"))
- filter = optarg + strlen("icmpv6,srt,");
+ if (strstr(opt_arg, "icmpv6,srt,"))
+ filter = opt_arg + strlen("icmpv6,srt,");
icmpv6stat = (icmpv6stat_t *)g_try_malloc(sizeof(icmpv6stat_t));
if (icmpv6stat == NULL) {
}
static void
-iostat_init(const char *optarg, void* userdata _U_)
+iostat_init(const char *opt_arg, void* userdata _U_)
{
gdouble interval_float;
guint32 idx=0;
io_stat_t *io;
const gchar *filters, *str, *pos;
- if ((*(optarg+(strlen(optarg)-1)) == ',') ||
- (sscanf(optarg, "io,stat,%lf%n", &interval_float, (int *)&idx) != 1) ||
+ if ((*(opt_arg+(strlen(opt_arg)-1)) == ',') ||
+ (sscanf(opt_arg, "io,stat,%lf%n", &interval_float, (int *)&idx) != 1) ||
(idx < 8)) {
fprintf(stderr, "\ntshark: invalid \"-z io,stat,<interval>[,<filter>][,<filter>]...\" argument\n");
exit(1);
}
- filters=optarg+idx;
+ filters=opt_arg+idx;
if (*filters) {
if (*filters != ',') {
/* For locale's that use ',' instead of '.', the comma might
interval of 1 and the last interval becomes "9 <> 9". If the interval is instead set to
1.1, the last interval becomes
last interval is rounded up to value that is greater than the duration. */
- const gchar *invl_start = optarg+8;
+ const gchar *invl_start = opt_arg+8;
gchar *intv_end;
int invl_len;
}
static void
-iousers_init(const char *optarg, void* userdata _U_)
+iousers_init(const char *opt_arg, void* userdata _U_)
{
const char *filter=NULL;
const char *tap_type, *tap_type_name;
io_users_t *iu=NULL;
GString *error_string;
- if(!strncmp(optarg,"conv,eth",8)){
- if(optarg[8]==','){
- filter=optarg+9;
+ if(!strncmp(opt_arg,"conv,eth",8)){
+ if(opt_arg[8]==','){
+ filter=opt_arg+9;
} else {
filter=NULL;
}
tap_type="eth";
tap_type_name="Ethernet";
packet_func=iousers_eth_packet;
- } else if(!strncmp(optarg,"conv,fc",7)){
- if(optarg[7]==','){
- filter=optarg+8;
+ } else if(!strncmp(opt_arg,"conv,fc",7)){
+ if(opt_arg[7]==','){
+ filter=opt_arg+8;
} else {
filter=NULL;
}
tap_type="fc";
tap_type_name="Fibre Channel";
packet_func=iousers_fc_packet;
- } else if(!strncmp(optarg,"conv,fddi",9)){
- if(optarg[9]==','){
- filter=optarg+10;
+ } else if(!strncmp(opt_arg,"conv,fddi",9)){
+ if(opt_arg[9]==','){
+ filter=opt_arg+10;
} else {
filter=NULL;
}
tap_type="fddi";
tap_type_name="FDDI";
packet_func=iousers_fddi_packet;
- } else if(!strncmp(optarg,"conv,tcp",8)){
- if(optarg[8]==','){
- filter=optarg+9;
+ } else if(!strncmp(opt_arg,"conv,tcp",8)){
+ if(opt_arg[8]==','){
+ filter=opt_arg+9;
} else {
filter=NULL;
}
tap_type="tcp";
tap_type_name="TCP";
packet_func=iousers_tcpip_packet;
- } else if(!strncmp(optarg,"conv,udp",8)){
- if(optarg[8]==','){
- filter=optarg+9;
+ } else if(!strncmp(opt_arg,"conv,udp",8)){
+ if(opt_arg[8]==','){
+ filter=opt_arg+9;
} else {
filter=NULL;
}
tap_type="udp";
tap_type_name="UDP";
packet_func=iousers_udpip_packet;
- } else if(!strncmp(optarg,"conv,tr",7)){
- if(optarg[7]==','){
- filter=optarg+8;
+ } else if(!strncmp(opt_arg,"conv,tr",7)){
+ if(opt_arg[7]==','){
+ filter=opt_arg+8;
} else {
filter=NULL;
}
tap_type="tr";
tap_type_name="Token Ring";
packet_func=iousers_tr_packet;
- } else if(!strncmp(optarg,"conv,ipx",8)){
- if(optarg[8]==','){
- filter=optarg+9;
+ } else if(!strncmp(opt_arg,"conv,ipx",8)){
+ if(opt_arg[8]==','){
+ filter=opt_arg+9;
} else {
filter=NULL;
}
tap_type="ipx";
tap_type_name="IPX";
packet_func=iousers_ipx_packet;
- } else if(!strncmp(optarg,"conv,ipv6",9)){
- if(optarg[9]==','){
- filter=optarg+10;
+ } else if(!strncmp(opt_arg,"conv,ipv6",9)){
+ if(opt_arg[9]==','){
+ filter=opt_arg+10;
} else {
filter=NULL;
}
tap_type="ipv6";
tap_type_name="IPv6";
packet_func=iousers_ipv6_packet;
- } else if(!strncmp(optarg,"conv,ip",7)){
- if(optarg[7]==','){
- filter=optarg+8;
+ } else if(!strncmp(opt_arg,"conv,ip",7)){
+ if(opt_arg[7]==','){
+ filter=opt_arg+8;
} else {
filter=NULL;
}
tap_type="ip";
tap_type_name="IPv4";
packet_func=iousers_ip_packet;
- } else if(!strncmp(optarg,"conv,sctp",9)) {
- if(optarg[9]==','){
- filter=optarg+10;
+ } else if(!strncmp(opt_arg,"conv,sctp",9)) {
+ if(opt_arg[9]==','){
+ filter=opt_arg+10;
} else {
filter=NULL;
}
}
/* Create a new MAC LTE stats struct */
-static void mac_lte_stat_init(const char *optarg, void *userdata _U_)
+static void mac_lte_stat_init(const char *opt_arg, void *userdata _U_)
{
mac_lte_stat_t *hs;
const char *filter = NULL;
GString *error_string;
/* Check for a filter string */
- if (strncmp(optarg, "mac-lte,stat,", 13) == 0) {
+ if (strncmp(opt_arg, "mac-lte,stat,", 13) == 0) {
/* Skip those characters from filter to display */
- filter = optarg + 13;
+ filter = opt_arg + 13;
}
else {
/* No filter */
static void
-megacostat_init(const char *optarg, void* userdata _U_)
+megacostat_init(const char *opt_arg, void* userdata _U_)
{
megacostat_t *ms;
int i;
}
ms=g_new(megacostat_t,1);
- if(!strncmp(optarg,"megaco,rtd,",11)){
- ms->filter=g_strdup(optarg+11);
+ if(!strncmp(opt_arg,"megaco,rtd,",11)){
+ ms->filter=g_strdup(opt_arg+11);
} else {
ms->filter=NULL;
}
static void
-mgcpstat_init(const char *optarg, void* userdata _U_)
+mgcpstat_init(const char *opt_arg, void* userdata _U_)
{
mgcpstat_t *ms;
int i;
GString *error_string;
ms=g_new(mgcpstat_t,1);
- if(!strncmp(optarg,"mgcp,rtd,",9)){
- ms->filter=g_strdup(optarg+9);
+ if(!strncmp(opt_arg,"mgcp,rtd,",9)){
+ ms->filter=g_strdup(opt_arg+9);
} else {
ms->filter=NULL;
}
static void
-protocolinfo_init(const char *optarg, void* userdata _U_)
+protocolinfo_init(const char *opt_arg, void* userdata _U_)
{
pci_t *rs;
const char *field=NULL;
header_field_info *hfi;
GString *error_string;
- if(!strncmp("proto,colinfo,",optarg,14)){
- filter=optarg+14;
+ if(!strncmp("proto,colinfo,",opt_arg,14)){
+ filter=opt_arg+14;
field=strchr(filter,',');
if(field){
field+=1; /* skip the ',' */
static void
-protohierstat_init(const char *optarg, void* userdata _U_)
+protohierstat_init(const char *opt_arg, void* userdata _U_)
{
phs_t *rs;
int pos=0;
const char *filter=NULL;
GString *error_string;
- if(strcmp("io,phs",optarg)==0){
+ if(strcmp("io,phs",opt_arg)==0){
/* No arguments */
- } else if(sscanf(optarg,"io,phs,%n",&pos)==0){
+ } else if(sscanf(opt_arg,"io,phs,%n",&pos)==0){
if(pos){
- filter=optarg+pos;
+ filter=opt_arg+pos;
}
} else {
fprintf(stderr, "tshark: invalid \"-z io,phs[,<filter>]\" argument\n");
static void
-radiusstat_init(const char *optarg, void* userdata _U_)
+radiusstat_init(const char *opt_arg, void* userdata _U_)
{
radiusstat_t *rs;
int i;
GString *error_string;
rs=g_new(radiusstat_t,1);
- if(!strncmp(optarg,"radius,rtd,",11)){
- rs->filter=g_strdup(optarg+11);
+ if(!strncmp(opt_arg,"radius,rtd,",11)){
+ rs->filter=g_strdup(opt_arg+11);
} else {
rs->filter=NULL;
}
/* Create a new RLC LTE stats struct */
-static void rlc_lte_stat_init(const char *optarg, void *userdata _U_)
+static void rlc_lte_stat_init(const char *opt_arg, void *userdata _U_)
{
rlc_lte_stat_t *hs;
const char *filter = NULL;
GString *error_string;
/* Check for a filter string */
- if (strncmp(optarg, "rlc-lte,stat,", 13) == 0) {
+ if (strncmp(opt_arg, "rlc-lte,stat,", 13) == 0) {
/* Skip those characters from filter to display */
- filter = optarg + 13;
+ filter = opt_arg + 13;
}
else {
/* No filter */
static void
-rpcprogs_init(const char *optarg _U_, void* userdata _U_)
+rpcprogs_init(const char *opt_arg _U_, void* userdata _U_)
{
GString *error_string;
* instance for the rpc tap.
*/
static void
-rpcstat_init(const char *optarg, void* userdata _U_)
+rpcstat_init(const char *opt_arg, void* userdata _U_)
{
rpcstat_t *rs;
guint32 i;
const char *filter=NULL;
GString *error_string;
- if(sscanf(optarg,"rpc,srt,%d,%d,%n",&program,&version,&pos)==2){
+ if(sscanf(opt_arg,"rpc,srt,%d,%d,%n",&program,&version,&pos)==2){
if(pos){
- filter=optarg+pos;
+ filter=opt_arg+pos;
} else {
filter=NULL;
}
static void
-rtp_streams_stat_init(const char *optarg _U_, void* userdata _U_)
+rtp_streams_stat_init(const char *opt_arg _U_, void* userdata _U_)
{
GString *err_p;
/* When called, this function will create a new instance of gtk_rtspstat.
*/
static void
-gtk_rtspstat_init(const char *optarg,void* userdata _U_)
+gtk_rtspstat_init(const char *opt_arg,void* userdata _U_)
{
rtspstat_t *sp;
const char *filter=NULL;
GString *error_string;
- if (!strncmp (optarg, "rtsp,stat,", 10)){
- filter=optarg+10;
+ if (!strncmp (opt_arg, "rtsp,stat,", 10)){
+ filter=opt_arg+10;
} else {
filter=NULL;
}
}
static void
-scsistat_init(const char *optarg, void* userdata _U_)
+scsistat_init(const char *opt_arg, void* userdata _U_)
{
scsistat_t *rs;
guint32 i;
GString *error_string;
pos=0;
- if(sscanf(optarg, "scsi,srt,%d,%n", &program, &pos)==1) {
+ if(sscanf(opt_arg, "scsi,srt,%d,%n", &program, &pos)==1) {
if(pos) {
- filter=optarg+pos;
+ filter=opt_arg+pos;
} else {
filter=NULL;
}
static void
-sctpstat_init(const char *optarg, void* userdata _U_)
+sctpstat_init(const char *opt_arg, void* userdata _U_)
{
sctpstat_t *hs;
GString *error_string;
hs = (sctpstat_t *)g_malloc(sizeof(sctpstat_t));
- if(!strncmp(optarg,"sctp,stat,",11)){
- hs->filter=g_strdup(optarg+11);
+ if(!strncmp(opt_arg,"sctp,stat,",11)){
+ hs->filter=g_strdup(opt_arg+11);
} else {
hs->filter=NULL;
}
}
static void
-sipstat_init(const char *optarg, void* userdata _U_)
+sipstat_init(const char *opt_arg, void* userdata _U_)
{
sipstat_t *sp;
const char *filter=NULL;
GString *error_string;
- if (strncmp (optarg, "sip,stat,", 9) == 0){
- filter=optarg+9;
+ if (strncmp (opt_arg, "sip,stat,", 9) == 0){
+ filter=opt_arg+9;
} else {
filter=NULL;
}
static void
-smbsids_init(const char *optarg _U_, void* userdata _U_)
+smbsids_init(const char *opt_arg _U_, void* userdata _U_)
{
GString *error_string;
static void
-smbstat_init(const char *optarg,void* userdata _U_)
+smbstat_init(const char *opt_arg,void* userdata _U_)
{
smbstat_t *ss;
guint32 i;
const char *filter=NULL;
GString *error_string;
- if(!strncmp(optarg,"smb,srt,",8)){
- filter=optarg+8;
+ if(!strncmp(opt_arg,"smb,srt,",8)){
+ filter=opt_arg+8;
} else {
filter=NULL;
}
}
static void
-init_stats_tree(const char *optarg, void *userdata _U_)
+init_stats_tree(const char *opt_arg, void *userdata _U_)
{
- char *abbr = stats_tree_get_abbr(optarg);
+ char *abbr = stats_tree_get_abbr(opt_arg);
GString *error_string;
stats_tree_cfg *cfg = NULL;
stats_tree *st = NULL;
cfg = stats_tree_get_cfg_by_abbr(abbr);
if (cfg != NULL) {
- if (strncmp (optarg, cfg->pr->init_string, strlen(cfg->pr->init_string)) == 0){
- st = stats_tree_new(cfg,NULL,optarg+strlen(cfg->pr->init_string));
+ if (strncmp (opt_arg, cfg->pr->init_string, strlen(cfg->pr->init_string)) == 0){
+ st = stats_tree_new(cfg,NULL,opt_arg+strlen(cfg->pr->init_string));
} else {
report_failure("Wrong stats_tree (%s) found when looking at ->init_string",abbr);
return;
g_free(abbr);
} else {
- report_failure("could not obtain stats_tree abbr (%s) from arg '%s'",abbr,optarg);
+ report_failure("could not obtain stats_tree abbr (%s) from arg '%s'",abbr,opt_arg);
return;
}
}
static void
-svstat_init(const char *optarg _U_, void* userdata _U_)
+svstat_init(const char *opt_arg _U_, void* userdata _U_)
{
GString *error_string;
* new instance for the wsp tap.
*/
static void
-wspstat_init(const char *optarg, void* userdata _U_)
+wspstat_init(const char *opt_arg, void* userdata _U_)
{
wspstat_t *sp;
const char *filter=NULL;
wsp_status_code_t *sc;
const value_string *wsp_vals_status_p;
- if (!strncmp (optarg, "wsp,stat," , 9)){
- filter=optarg+9;
+ if (!strncmp (opt_arg, "wsp,stat," , 9)){
+ filter=opt_arg+9;
} else {
filter=NULL;
}