int syscall_read(void)
{
int fd = (int) next_arg();
void *buf = next_arg();
int size = (int) next_arg();
//Don't perform operation if size is zero
if(size == 0)
return 0;
//Read from stdin
if(fd==0)
{
int i;
char * char_buffer = buf;
for(i=0; i < size; i++)
{
char_buffer[i] = input_getc();
}
return size;
}
//Perform operation onbly if the given fd is in the calling threads
//open fd list
else if(thread_has_fd(fd))
{
return file_read(file_get_file(fd),buf,size);
}
return -1;
}
// draw a box directly to display memory
int _near Drawbox_Cmd( LPTSTR pszCmdLine )
{
register TCHAR *pszArg, *pszLine;
int nTop, nLeft, nBottom, nRight, nStyle, nAttribute = -1, nFill = -1, n, nFlags = 0, nShade;
if (( pszCmdLine == NULL ) || ( *pszCmdLine == _TEXT('\0') ))
return ( Usage( DRAWBOX_USAGE ));
// get the arguments & colors
if ( sscanf( pszCmdLine, _TEXT("%d%d%d%d%d%n"), &nTop, &nLeft, &nBottom, &nRight, &nStyle, &n ) == 6 ) {
pszLine = pszCmdLine + n;
nAttribute = GetColors( pszLine, 0 );
// check for a FILL color
if (( *pszLine ) && ( _strnicmp( first_arg( pszLine ), BOX_FILL, 3 ) == 0 ) && (( pszArg = first_arg( next_arg( pszLine, 1 ))) != NULL )) {
if ( _strnicmp( pszArg, BRIGHT, 3 ) == 0 ) {
// set intensity bit
nFill = 0x80;
if (( pszArg = first_arg( next_arg( pszLine, 1 ))) == NULL )
return ( Usage( DRAWBOX_USAGE ));
} else
nFill = 0;
if (( nShade = color_shade( pszArg )) <= 15 ) {
nFill |= ( nShade << 4 );
next_arg( pszLine, 1 );
}
}
// check for a SHADOW or ZOOM
while ( *pszLine ) {
if ( _strnicmp( pszLine, BOX_SHADOW, 3 ) == 0 )
nFlags |= BOX_SHADOWED;
else if ( _strnicmp( pszLine, BOX_ZOOM, 3 ) == 0 )
nFlags |= BOX_ZOOMED;
next_arg( pszLine, 1 );
}
}
if (( nAttribute == -1 ) || ( verify_row_col( nTop, nLeft )) || ( verify_row_col( nBottom, nRight )))
return ( Usage( DRAWBOX_USAGE ));
if ( nLeft == 999 ) {
if (( nLeft = (( GetScrCols() - nRight ) / 2 )) < 0 )
nLeft = 0;
nRight += nLeft;
}
if ( nTop == 999 ) {
if (( nTop = (( GetScrRows() - nBottom ) / 2 )) < 0 )
nTop = 0;
nBottom += nTop;
}
_box( nTop, nLeft, nBottom, nRight, nStyle, nAttribute, nFill, nFlags, 1 );
return 0;
}
unsigned int set_usermode(char *mode, unsigned int level)
{
char *av;
int neg = 0;
int i, p;
av = next_arg(&mode);
while (av)
{
if(!strcasecmp(av, "ALL"))
level = LOGALL_MODE;
else if(!strcasecmp(av, "NONE"))
level = 0;
else if(*av == '-')
{
neg = 1;
av++;
}
else
neg = 0;
for (i = 0, p = 1; *User_Levels[i]; i++, p <<= 1)
{
if(!strcasecmp(av, User_Levels[i]))
{
if(neg)
level &= (LOGALL_MODE ^ p);
else
level |= p;
break;
}
}
av = next_arg(&mode);
}
return level;
}
int delay_flush_all (void *arg, char *sub)
{
char buffer[BIG_BUFFER_SIZE+1];
char *args = (char *)arg;
char *serv_num = NULL;
char *channel = NULL;
int ofs = from_server;
channel = next_arg(args, &args);
if ((serv_num = next_arg(args, &args)))
from_server = atoi(serv_num);
if (channel && *channel && mode_str && user)
{
sprintf(buffer, "MODE %s %s%s %s\r\n", channel, plus_mode, mode_str, user);
push_len = strlen(buffer);
add_mode_buffer(buffer, push_len);
mode_str_len = 0;
new_free(&mode_str);
new_free(&user);
memset(plus_mode, 0, sizeof(plus_mode));
push_len = 0;
}
flush_mode(NULL);
new_free(&arg);
from_server = ofs;
return 0;
}
int real_check_auto (void *arg, char *sub)
{
char *nick, *host, *channel;
char *p = (char *)arg;
char *args = (char *)arg;
char *serv_num = NULL;
int this_server = from_server;
channel = next_arg(args, &args);
nick = next_arg(args, &args);
host = next_arg(args, &args);
if ((serv_num = next_arg(args, &args)))
from_server = my_atol(serv_num);
if (channel && *channel && nick && *nick && host && *host)
{
ChannelList *chan;
if ((chan = lookup_channel(channel, from_server, CHAN_NOUNLINK)))
check_auto(channel, find_nicklist_in_channellist(nick, chan, 0), NULL);
}
this_server = from_server;
new_free(&p);
return 0;
}
void SessionRep::extract(
const String& arg, const OptionDesc& o, int& i, int argc, char** argv,
String& name, String& value
) {
int colon;
switch (o.style) {
case OptionPropertyNext:
value = next_arg(i, argc, argv, "missing property after '%s'", arg);
colon = value.index(':');
if (colon < 0) {
bad_arg("missing ':' in '%s'", value);
} else {
name = value.left(colon);
value = value.right(colon+1);
}
break;
case OptionValueNext:
name = o.path;
value = next_arg(i, argc, argv, "missing value after '%s'", arg);
break;
case OptionValueImplicit:
name = o.path;
value = o.value;
break;
case OptionValueIsArg:
name = o.path;
value = arg;
break;
case OptionValueAfter:
bad_arg("missing value in '%s'", arg);
break;
}
}
void prepare_addshit(UserhostItem *stuff, char *nick, char *args)
{
char *uh;
char *channels, *reason;
char listbuf[BIG_BUFFER_SIZE+1];
int thetype = 0, shit = 0;
if (!stuff || !stuff->nick || !nick || !strcmp(stuff->user, "<UNKNOWN>") || my_stricmp(stuff->nick, nick))
{
bitchsay("No such nick [%s] found", nick);
return;
}
thetype = my_atol(args);
next_arg(args, &args);
shit = my_atol(args);
next_arg(args, &args);
channels = next_arg(args, &args);
reason = args;
uh = clear_server_flags(stuff->user);
while (strlen(uh) > 7) uh++;
sprintf(listbuf, "*%s@%s", uh, stuff->host);
add_to_a_list(listbuf, thetype, "*", channels, reason, shit);
}
args_t::args_t( int argc, const char * argv[] ) :
output( stdout ),
input1( stdin ),
input2( NULL ),
distance( DEFAULT_DISTANCE ),
min_distance( DEFAULT_MIN_DISTANCE ),
ambig( DEFAULT_AMBIG ),
format ( DEFAULT_FORMAT ),
overlap ( DEFAULT_OVERLAP ),
do_bootstrap( false ),
do_bootstrap_two_files ( false ),
do_count( false ),
quiet( false ),
do_fst( false ),
report_self ( false ),
counts_in_name ( DEFAULT_COUNTS_IN_NAME ),
include_prob( DEFAULT_INCLUDE_PROB ),
ambigs_to_resolve(NULL),
resolve_fraction(DEFAULT_FRACTION)
{
// skip arg[0], it's just the program name
for (int i = 1; i < argc; ++i ) {
const char * arg = argv[i];
if ( arg[0] == '-' && arg[1] == '-' ) {
if ( !strcmp( &arg[2], "help" ) ) help();
else if ( !strcmp( &arg[2], "version" ) ) version();
else
ERROR( "unknown argument: %s", arg );
}
else if ( arg[0] == '-' ) {
if ( !strcmp( &arg[1], "h" ) ) help();
else if ( arg[1] == 'v' ) version();
else if ( arg[1] == 'o' ) parse_output( next_arg (i, argc, argv) );
else if ( arg[1] == 't' ) parse_distance ( next_arg (i, argc, argv) );
else if ( arg[1] == 'w' ) parse_min_distance ( next_arg (i, argc, argv) );
else if ( arg[1] == 'l') parse_overlap( next_arg (i, argc, argv) );
else if ( arg[1] == 'f') parse_format( next_arg (i, argc, argv) );
else if ( arg[1] == 'a') parse_ambig( next_arg (i, argc, argv) );
else if ( arg[1] == 's') parse_second_in( next_arg (i, argc, argv) );
else if ( arg[1] == 'd') parse_counts_in_name( next_arg (i, argc, argv) );
else if ( arg[1] == 'u') parse_include_prob( next_arg (i, argc, argv) );
else if ( arg[1] == 'b') parse_bootstrap();
else if ( arg[1] == 'r') parse_bootstrap_two_files ();
else if ( arg[1] == 'c') parse_count();
else if ( arg[1] == 'q') parse_quiet();
else if ( arg[1] == 'm') parse_fst();
else if ( arg[1] == '0') parse_report_self();
else if ( arg[1] == 'g') parse_fraction( next_arg (i, argc, argv) );
else
ERROR( "unknown argument: %s", arg );
}
else
if (i == argc-1) {
parse_input (arg);
} else {
ERROR( "unknown argument: %s", arg );
}
}
}
args_t::args_t( int argc, const char * argv[] ) :
output( stdout ),
input( stdin ),
ambig( DEFAULT_AMBIG ),
data ( DEFAULT_DATA ),
counts_in_name ( DEFAULT_COUNTS_IN_NAME ),
quiet (false)
{
// skip arg[0], it's just the program name
for (int i = 1; i < argc; ++i ) {
const char * arg = argv[i];
if ( arg[0] == '-' && arg[1] == '-' ) {
if ( !strcmp( &arg[2], "help" ) ) help();
else
ERROR( "unknown argument: %s", arg );
}
else if ( arg[0] == '-' ) {
if ( !strcmp( &arg[1], "h" ) ) help();
else if ( arg[1] == 'o' ) parse_output( next_arg (i, argc, argv) );
else if ( arg[1] == 'a') parse_ambig( next_arg (i, argc, argv) );
else if ( arg[1] == 't') parse_data ( next_arg (i, argc, argv) );
else if ( arg[1] == 'd') parse_counts_in_name( next_arg (i, argc, argv) );
else if ( arg[1] == 'q') parse_quiet ( );
else
ERROR( "unknown argument: %s", arg );
}
else
if (i == argc-1) {
parse_input (arg);
} else {
ERROR( "unknown argument: %s", arg );
}
}
}
int main(int argc, char** argv) {
int i;
char buf[256];
sim_results.clear();
for (i=1; i<argc;) {
char* opt = argv[i++];
if (!strcmp(opt, "--infile_prefix")) {
infile_prefix = argv[i++];
} else if (!strcmp(opt, "--outfile_prefix")) {
outfile_prefix = argv[i++];
} else if (!strcmp(opt, "--existing_jobs_only")) {
existing_jobs_only = true;
} else if (!strcmp(opt, "--duration")) {
duration = atof(next_arg(argc, argv, i));
} else if (!strcmp(opt, "--delta")) {
delta = atof(next_arg(argc, argv, i));
} else if (!strcmp(opt, "--server_uses_workload")) {
server_uses_workload = true;
} else if (!strcmp(opt, "--cpu_sched_rr_only")) {
cpu_sched_rr_only = true;
} else if (!strcmp(opt, "--include_empty_projects")) {
include_empty_projects = true;
} else if (!strcmp(opt, "--rec_half_life")) {
cc_config.rec_half_life = atof(argv[i++]);
} else {
usage(argv[0]);
}
}
if (duration <= 0) {
fprintf(stderr, "duration <= 0\n");
exit(1);
}
if (delta <= 0) {
fprintf(stderr, "delta <= 0\n");
exit(1);
}
sprintf(buf, "%s%s", outfile_prefix, "index.html");
index_file = fopen(buf, "w");
sprintf(log_filename, "%s%s", outfile_prefix, LOG_FNAME);
logfile = fopen(log_filename, "w");
if (!logfile) {
fprintf(stderr, "Can't open %s\n", buf);
exit(1);
}
setbuf(logfile, 0);
sprintf(buf, "%s%s", outfile_prefix, REC_FNAME);
rec_file = fopen(buf, "w");
sprintf(buf, "%s%s", outfile_prefix, SUMMARY_FNAME);
summary_file = fopen(buf, "w");
srand(1); // make it deterministic
do_client_simulation();
}
static void set_cset_var_value(CSetList *tmp, int var_index, char *value)
{
char *rest;
CSetArray *var;
var = &(cset_array[var_index]);
switch (var->type)
{
case BOOL_TYPE_VAR:
if (value && *value && (value = next_arg(value, &rest))) {
if (do_boolean(value, (int *)get_cset_int_var_address(tmp, var_index)))
{
say("Value must be either ON, OFF, or TOGGLE");
break;
}
if (var->func)
var->func(var, tmp);
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF]));
}
else
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_int_var(tmp, var_index)?var_settings[ON] : var_settings[OFF]));
break;
case INT_TYPE_VAR:
if (value && *value && (value = next_arg(value, &rest)))
{
int val;
if (!is_number(value))
{
say("Value of %s must be numeric!", var->name);
break;
}
if ((val = atoi(value)) < 0)
{
say("Value of %s must be greater than 0", var->name);
break;
}
set_cset_int_var(tmp, var_index, val);
if (var->func)
var->func(var, tmp);
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index)));
}
else
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %d", var->name, tmp->channel, get_cset_int_var(tmp, var_index)));
break;
case STR_TYPE_VAR:
if (value && *value)
{
set_cset_str_var(tmp, var_index, value);
if (var->func)
var->func(var, tmp);
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, get_cset_str_var(tmp, var_index) ));
}
else
put_it("%s", convert_output_format(fget_string_var(FORMAT_CSET_FSET), "%s %s %s", var->name, tmp->channel, (char *)get_cset_str_var(tmp, var_index)));
}
}
unsigned long hypercall_create_continuation(
unsigned int op, const char *format, ...)
{
struct mc_state *mcs = ¤t->mc_state;
struct cpu_user_regs *regs;
const char *p = format;
unsigned long arg, rc;
unsigned int i;
va_list args;
/* All hypercalls take at least one argument */
BUG_ON( !p || *p == '\0' );
va_start(args, format);
if ( test_bit(_MCSF_in_multicall, &mcs->flags) )
{
BUG(); /* XXX multicalls not implemented yet. */
__set_bit(_MCSF_call_preempted, &mcs->flags);
for ( i = 0; *p != '\0'; i++ )
mcs->call.args[i] = next_arg(p, args);
/* Return value gets written back to mcs->call.result */
rc = mcs->call.result;
}
else
{
regs = guest_cpu_user_regs();
regs->r12 = op;
/* Ensure the hypercall trap instruction is re-executed. */
regs->pc -= 4; /* re-execute 'hvc #XEN_HYPERCALL_TAG' */
for ( i = 0; *p != '\0'; i++ )
{
arg = next_arg(p, args);
switch ( i )
{
case 0: regs->r0 = arg; break;
case 1: regs->r1 = arg; break;
case 2: regs->r2 = arg; break;
case 3: regs->r3 = arg; break;
case 4: regs->r4 = arg; break;
case 5: regs->r5 = arg; break;
}
}
/* Return value gets written back to r0 */
rc = regs->r0;
}
va_end(args);
return rc;
}
void input_msgreply(char dumb, char *dumber)
{
char *cmdchar;
char *line, *cmd, *t;
char *snick;
NickTab *nick = NULL;
int got_space = 0;
if (!(cmdchar = get_string_var(CMDCHARS_VAR)))
cmdchar = DEFAULT_CMDCHARS;
t = line = m_strdup(get_input());
if (t)
got_space = strchr(t, ' ') ? 1 : 0;
cmd = next_arg(line, &line);
snick = next_arg(line, &line);
if ((cmd && *cmd == *cmdchar && got_space) || !cmd) {
if (cmd && *cmd == *cmdchar)
cmd++;
if (in_completion == STATE_NORMAL && snick)
strncpy(new_nick, snick, sizeof(new_nick) - 1);
if ((nick = getnextnick(new_nick, input_lastmsg, snick))) {
if (nick->nick && *(nick->nick)) {
snick = nick->nick;
malloc_strcpy(&input_lastmsg, nick->nick);
}
}
if (nick) {
char *tmp = NULL;
input_clear_line('\0', NULL);
if (get_fset_var(FORMAT_NICK_MSG_FSET))
malloc_strcpy(&tmp,
stripansicodes(convert_output_format
(get_fset_var(FORMAT_NICK_MSG_FSET), "%s%s %s %s", cmdchar,
nick->type ? nick->type : cmd ? cmd : "msg", nick->nick, line ? line : empty_str)));
else
malloc_sprintf(&tmp, "%s%s %s %s", cmdchar, nick->type ? nick->type : cmd ? cmd : "msg", nick->nick,
line ? line : empty_str);
set_input(tmp);
new_free(&tmp);
} else
command_completion(0, NULL);
} else
command_completion(0, NULL);
update_input(UPDATE_ALL);
new_free(&t);
}
void
cmd_replace()
{
int m, n;
get_int_opt(&m);
next_arg();
get_int_opt(&n);
if (m > n) notif_error("First argument cannot be greater than the second");
next_arg();
copy_lines(m - 1);
if (m < ln) return;
goto_line(n + 1);
write_text();
}
static Logfile * logfile_name (Logfile *log, char **args)
{
char *arg;
if (!log)
{
say("NAME: You need to specify a logfile first");
return NULL;
}
if (!(arg = next_arg(*args, args)))
say("You must specify a name for the logfile!");
else
{
/* /log name - unsets the window name */
if (!strcmp(arg, "-"))
new_free(&log->name);
/* /log name to existing name -- ignore this. */
else if (log->name && (my_stricmp(log->name, arg) == 0))
return log;
else if (is_logfile_name_unique(arg))
malloc_strcpy(&log->name, arg);
else
say("%s is not unique!", arg);
}
return log;
}
static Logfile * logfile_refnum (Logfile *log, char **args)
{
char *arg = next_arg(*args, args);
log = get_log_by_desc(arg);
return log;
}
/* Args looks like "foo=bar,bar2 baz=fuz wiz". */
static int parse_args(const char *doing,
char *args,
unsigned num,
s16 min_level,
s16 max_level,
int (*unknown)(char *param, char *val, const char *doing))
{
char *param, *val;
/* Chew leading spaces */
args = skip_spaces(args);
while (*args) {
int ret;
args = next_arg(args, ¶m, &val);
if (unknown)
ret = unknown(param, val, doing);
switch (ret) {
case -VMM_ENOENT:
return ret;
case -VMM_ENOSPC:
return ret;
case 0:
break;
default:
return ret;
}
}
/* All parsed OK. */
return 0;
}
static Logfile * logfile_filename (Logfile *log, char **args)
{
char * arg = next_arg(*args, args);
if (!log)
{
say("FILENAME: You need to specify a logfile first");
return NULL;
}
if (!arg)
{
if (log->filename)
say("Log %s is attached to %s", log->name, log->filename);
else
say("Log %s does not have a filename", log->name);
return log;
}
if (log->active)
logfile_off(log, NULL);
malloc_strcpy(&log->filename, arg);
if (log->active)
logfile_on(log, NULL);
return log;
}
/* Pops the next argument off the stack and checks it is a valid string. */
static char *next_str() {
ASSERT(lock_held_by_current_thread(&offset_lock));
char *s = (char *) next_arg();
validate_str(s);
return s;
}
char * function_xdebug (char *word)
{
char *ret = NULL, *free_str = NULL;
const char *mask = NULL;
int cnt;
size_t clue = 0;
mask = next_arg(word, &word);
mask = mask && *mask ? mask : star;
for (cnt = 0; opts[cnt].command; cnt++)
{
if (!~opts[cnt].flag) {
continue;
} else if (!wild_match(mask,opts[cnt].command)) {
continue;
} else if (x_debug & opts[cnt].flag) {
malloc_strcat_wordlist_c(&ret, space, "+", &clue);
} else {
malloc_strcat_wordlist_c(&ret, space, "-", &clue);
}
malloc_strcat_c(&ret, opts[cnt].command, &clue);
}
if (word && *word)
malloc_strcat_wordlist_c(&ret, space,
free_str = function_xdebug(word), &clue);
new_free(&free_str);
malloc_strcat_c(&ret, "", &clue);
return ret;
}
int delay_opz (void *arg, char *sub)
{
char * args = (char *)arg;
char * from = NULL;
char * host = NULL;
char * channel = NULL;
char * mode = NULL;
char * serv_num = NULL;
ChannelList *chan = NULL;
int this_server = from_server;
char *p = (char *) arg; /* original args unmodified so we can free them */
channel = next_arg(args, &args);
from = next_arg(args, &args);
host = next_arg(args, &args);
mode = next_arg(args, &args);
if ((serv_num = next_arg(args, &args)))
this_server = my_atol(serv_num);
chan = lookup_channel(channel, this_server, 0);
if (chan && is_on_channel(channel, this_server, from) && chan->chop)
{
NickList *nick;
for (nick = next_nicklist(chan, NULL); nick; nick = next_nicklist(chan, nick))
{
if (!my_stricmp(nick->nick, from))
{
if (!my_stricmp(host, nick->host))
break;
else
{
new_free(&p); new_free(&sub);
return 0;
}
}
}
if (nick && ((!nick_isop(nick) && *mode == 'o') || (!nick_isvoice(nick) && *mode == 'v')))
{
my_send_to_server(this_server, "MODE %s +%s %s", channel, mode, from);
if (get_int_var(SEND_OP_MSG_VAR))
my_send_to_server(this_server, "NOTICE %s :You have been delay Auto-%s'd", from, *mode == 'o'? "op":"voice");
}
}
new_free(&p); new_free(&sub);
return 0;
}
/*
* Entry point function for 'nmcli networking'
*/
NMCResultCode
do_networking (NmCli *nmc, int argc, char **argv)
{
gboolean enable_flag;
/* Register polkit agent */
nmc_start_polkit_agent_start_try (nmc);
if (argc == 0)
nmc_switch_show (nmc, NMC_FIELDS_NM_NETWORKING, _("Networking"));
else if (argc > 0) {
if (nmc_arg_is_help (*argv)) {
usage_networking ();
} else if (matches (*argv, "connectivity") == 0) {
if (nmc_arg_is_help (*(argv+1))) {
usage_networking_connectivity ();
goto finish;
}
if (next_arg (&argc, &argv) != 0) {
/* no arguments -> get current state */
show_networking_connectivity (nmc);
} else if (matches (*argv, "check") == 0) {
GError *error = NULL;
nmc->get_client (nmc); /* create NMClient */
nm_client_check_connectivity (nmc->client, NULL, &error);
if (error) {
g_string_printf (nmc->return_text, _("Error: %s."), error->message);
nmc->return_value = NMC_RESULT_ERROR_UNKNOWN;
g_clear_error (&error);
} else
show_networking_connectivity (nmc);
} else {
usage_networking ();
g_string_printf (nmc->return_text, _("Error: 'networking connectivity' command '%s' is not valid."), *argv);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
}
} else if (nmc_switch_parse_on_off (nmc, *(argv-1), *argv, &enable_flag)) {
if (nmc_arg_is_help (*(argv+1))) {
if (enable_flag)
usage_networking_on ();
else
usage_networking_off ();
goto finish;
}
nmc->get_client (nmc); /* create NMClient */
nm_client_networking_set_enabled (nmc->client, enable_flag, NULL);
} else {
usage_networking ();
g_string_printf (nmc->return_text, _("Error: 'networking' command '%s' is not valid."), *argv);
nmc->return_value = NMC_RESULT_ERROR_USER_INPUT;
}
}
finish:
quit ();
return nmc->return_value;
}
int str2devinfo(const char *dev_id_const, struct bladerf_devinfo *d)
{
char *dev_id, *token, *arg, *val, *saveptr;
int status, arg_status;
assert(d);
/* Prep our device info before we begin manpulating it, defaulting to
* a "wildcard" device indentification */
bladerf_init_devinfo(d);
/* No device indentifier -- pick anything we can find */
if ( dev_id_const == NULL || strlen(dev_id_const) == 0) {
return 0;
}
/* Copy the string so we can butcher it a bit while parsing */
dev_id = strdup(dev_id_const);
if (!dev_id) {
return BLADERF_ERR_MEM;
}
/* Extract backend */
token = strtok_r(dev_id, ":", &saveptr);
/* We require a valid backend -- args only is not supported */
if (token) {
status = handle_backend(token, d);
/* Loop over remainder of string, gathering up args */
arg_status = 1;
while (arg_status == 1 && status == 0) {
arg_status = next_arg(&saveptr, &arg, &val);
if (arg_status == 1) {
/* Handle argument if we can */
if (!strcasecmp("device", arg)) {
status = handle_device(d, val);
} else if (!strcasecmp("instance", arg)) {
status = handle_instance(d, val);
} else if (!strcasecmp("serial", arg)) {
status = handle_serial(d, val);
} else {
arg_status = BLADERF_ERR_INVAL;
}
}
};
if (arg_status < 0) {
status = arg_status;
}
} else {
status = BLADERF_ERR_INVAL;
}
free(dev_id);
return status;
}
static void parse_server_notice(char *from, char *line)
{
int flag = 0;
int up_status = 0;
const char *f;
f = from;
if (!f || !*f)
if (!(f = get_server_itsname(from_server)))
f = get_server_name(from_server);
if (*line != '*' && *line != '#' && strncmp(line, "MOTD ", 4))
flag = 1;
else
flag = 0;
if (do_hook(SERVER_NOTICE_LIST, flag?"%s *** %s":"%s %s", f, line))
{
#ifdef WANT_OPERVIEW
if (handle_oper_vision(f, line, &up_status))
reset_display_target();
else
#endif
if (strstr(line, "***"))
{
set_display_target(NULL, LOG_SNOTE);
#ifdef WANT_OPERVIEW
if (get_int_var(OV_VAR) && !(get_server_ircop_flags(from_server) & SERVER_CRAP))
goto done1;
#endif
if (do_hook(SERVER_NOTICE_LIST, flag ? "%s *** %s" : "%s %s", f, line))
{
char *for_;
for_ = next_arg(line,&line);
serversay(1, from_server, "%s",
convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_FSET), "%s %s %s", update_clock(GET_TIME),
f, stripansicodes(line)));
add_last_type(&last_servermsg[0], MAX_LAST_MSG, NULL, NULL, NULL, line);
}
}
else
{
set_display_target(NULL, LOG_SNOTE);
#ifdef WANT_OPERVIEW
if (get_int_var(OV_VAR) && !(get_server_ircop_flags(from_server) & SERVER_CRAP))
goto done1;
#endif
if (do_hook(SERVER_NOTICE_LIST, flag ? "%s *** %s" : "%s %s", f, line))
serversay(1, from_server, "%s",
convert_output_format(fget_string_var(FORMAT_SERVER_NOTICE_FSET), "%s %s %s", update_clock(GET_TIME),
f, stripansicodes(line)));
add_last_type(&last_servermsg[0], MAX_LAST_MSG, NULL, NULL, NULL, line);
}
}
if (up_status)
update_all_status(current_window, NULL, 0);
done1:
reset_display_target();
}
// draw a box directly to display memory
int drawbox_cmd(int argc, char **argv)
{
char *arg, *pszLine;
int top, left, bottom, right, style, attribute = -1, fill = -1;
int box_flags = 0;
// get the arguments & colors
if ((argc >= 7) && (sscanf(argv[1],"%d%d%d%d%d",&top,&left,&bottom,&right,&style) == 5)) {
pszLine = argv[6];
attribute = GetColors(pszLine,0);
// check for a FILL color
if ((*pszLine) && (_strnicmp(first_arg(pszLine),BOX_FILL,3) == 0) && ((arg = first_arg(next_arg(pszLine,1))) != NULL)) {
if (_strnicmp(arg,BRIGHT,3) == 0) {
// set intensity bit
fill = 0x80;
if ((arg = first_arg(next_arg(pszLine,1))) == NULL)
return (usage(DRAWBOX_USAGE));
} else
fill = 0;
if ((argc = color_shade(arg)) <= 15) {
fill |= (argc << 4);
(void)next_arg(pszLine,1);
}
}
// check for a SHADOW or ZOOM
while (*pszLine) {
if (_strnicmp(pszLine,BOX_SHADOW,3) == 0)
box_flags |= BOX_SHADOWED;
else if (_strnicmp(pszLine,BOX_ZOOM,3) == 0)
box_flags |= BOX_ZOOMED;
(void)next_arg(pszLine,1);
}
}
if ((attribute == -1) || (verify_row_col(top,left)) || (verify_row_col(bottom,right)))
return (usage(DRAWBOX_USAGE));
_box(top,left,bottom,right,style,attribute,fill,box_flags,1);
return 0;
}
/*
* The client apparantly never was adapted to handle the new NOTE syntax.
* So i had to kludge this up to work with it. Currently, NOTEs are sent
* something like this:
*
* NOTICE yournick :Note from nick!user@host /xxxd:xxh:xxm/ [N] message
*
* and parse() calls parse_notice(), who notices that there is no pefix
* and passes it off to parse_local_server_notice(), who checks to see
* if it is a note (it is), blows away the "Note from" part, and re-sets
* the "from" and "FromUserHost" parts with the nick!user@host part and
* passes us the buck with 'line' pointing at the time description
* (the /.../ part)
*/
static void parse_note (char *from, char *line)
{
char *date,
*flags,
*high;
time_t when;
int level;
switch (check_ignore(from, FromUserHost, IGNORE_NOTES))
{
case IGNORED:
return;
case HIGHLIGHTED:
high = highlight_char;
break;
default:
high = empty_string;
}
if (check_flooding(from, FromUserHost, NOTE_FLOOD, line))
return;
/*
at this point, line looks like:
"/xxxd:xxh:xxm/ [FLAGS] message goes here"
*/
date = next_arg(line, &line);
flags = next_arg(line, &line);
when = convert_note_time_to_real_time(date);
level = set_lastlog_msg_level(LOG_NOTES);
if (do_hook(NOTE_LIST, "%s %lu %s", from, when, line))
{
if (time(NULL) - when > 60) /* not just sent */
put_it("%s[%s]%s %s (%s)", high, from, high,
line, my_ctime(when));
else
put_it("%s[%s]%s %s", high, from, high, line);
}
if (beep_on_level & LOG_NOTES)
beep_em(1);
set_lastlog_msg_level(level);
}
int pub_proc(char *which, char *str, char **unused) {
char *loc, *nick, *chan, *cmd, *serv;
unsigned short port = 0;
if(qbx_on == 0) return 1;
loc = LOCAL_COPY(str);
nick = next_arg(loc, &loc);
chan = next_arg(loc, &loc);
cmd = next_arg(loc, &loc);
if(cmd && *cmd != '!') return 1;
if(my_stricmp(cmd, Q3A_COMMAND) && my_stricmp(cmd, Q2_COMMAND) && my_stricmp(cmd, QW_COMMAND))
return 1;
serv = next_arg(loc, &loc);
if(serv == NULL) {
privmsg(chan, "%s: Give me a server to query", nick);
return 1;
}
if(querying == 1) {
privmsg(chan, "%s: A query is already in progress", nick);
return 1;
}
if(strchr(serv, ':')) {
serv = strtok(serv, ":");
port = atoi(strtok(NULL, ""));
}
else
port = 0;
strncpy(q_chan, chan, 256);
if(!my_stricmp(cmd, Q3A_COMMAND)) { /* quake3 server (my fav =) */
if(port == 0) port = Q3A_GAME_PORT;
query_q_server(serv, port, 3);
return 1;
}
else if(!my_stricmp(cmd, Q2_COMMAND)) { /* quake2 server */
if(port == 0) port = Q2_GAME_PORT;
query_q_server(serv, port, 2);
return 1;
}
else if(!my_stricmp(cmd, QW_COMMAND)) { /* quakeworld server */
if(port == 0) port = QW_GAME_PORT;
query_q_server(serv, port, 1);
return 1;
}
return 1;
}
int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
unsigned flags)
{
int a = -1;
int skip = 0;
int i;
int n;
struct isl_prefixes prefixes = { 0 };
n = n_arg(args->args);
for (i = 1; i < argc; ++i) {
if ((strcmp(argv[i], "--version") == 0 ||
strcmp(argv[i], "-V") == 0) && any_version(args->args))
print_version_and_exit(args->args);
}
while (argc > 1 + skip) {
int parsed;
if (argv[1 + skip][0] != '-') {
a = next_arg(args->args, a);
if (a >= 0) {
char **p;
p = (char **)(((char *)opt)+args->args[a].offset);
free(*p);
*p = strdup(argv[1 + skip]);
argc = drop_argument(argc, argv, 1 + skip, 1);
--n;
} else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
fprintf(stderr, "%s: extra argument: %s\n",
prog_name(argv[0]), argv[1 + skip]);
exit(-1);
} else
++skip;
continue;
}
check_help(args, argv[1 + skip], argv[0], opt, flags);
parsed = parse_option(args->args, &argv[1 + skip],
&prefixes, opt);
if (parsed)
argc = drop_argument(argc, argv, 1 + skip, parsed);
else if (ISL_FL_ISSET(flags, ISL_ARG_ALL)) {
fprintf(stderr, "%s: unrecognized option: %s\n",
prog_name(argv[0]), argv[1 + skip]);
exit(-1);
} else
++skip;
}
if (n > 0) {
fprintf(stderr, "%s: expecting %d more argument(s)\n",
prog_name(argv[0]), n);
exit(-1);
}
return argc;
}
unsigned long parse_lastlog_level(char *str, int display)
{
char *ptr,
*rest;
int len,
i;
unsigned long p,
level;
int neg;
level = 0;
while ((str = next_arg(str, &rest)) != NULL)
{
while (str)
{
if ((ptr = strchr(str, ',')) != NULL)
*ptr++ = '\0';
if ((len = strlen(str)) != 0)
{
if (my_strnicmp(str, "ALL", len) == 0)
level = LOG_ALL;
else if (my_strnicmp(str, "NONE", len) == 0)
level = 0;
else
{
if (*str == '-')
{
str++; len--;
neg = 1;
}
else
neg = 0;
for (i = 0, p = 1; i < NUMBER_OF_LEVELS; i++, p <<= 1)
{
if (!my_strnicmp(str, levels[i], len))
{
if (neg)
level &= (LOG_ALL ^ p);
else
level |= p;
break;
}
}
if (i == NUMBER_OF_LEVELS)
{
if (display)
say("Unknown lastlog level: %s", str);
return LOG_ALL;
}
}
}
str = ptr;
}
str = rest;
}
return (level);
}
void ison_notify(char *AskedFor, char *AreOn)
{
char *NextAsked;
char *NextGot;
NextGot = next_arg(AreOn, &AreOn);
while ((NextAsked = next_arg(AskedFor, &AskedFor)) != NULL)
{
if (NextGot && !my_stricmp(NextAsked, NextGot))
{
notify_mark(NextAsked, NULL, 1, 1);
NextGot = next_arg(AreOn, &AreOn);
}
else
notify_mark(NextAsked, NULL, 0, 1);
}
dispatch_notify_userhosts();
}
