static int lua_get_session_network(lua_State *L)
{
char network[80]={0};
if(lua_gettop(L)==1){
const void *session;
session=lua_touserdata(L,1);
if(session){
get_session_info(session,network,sizeof(network));
}
}
lua_pushstring(L,network);
return 1;
}
static long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct iscsi_target *target = NULL;
long err;
u32 id;
if ((err = get_user(id, (u32 *) arg)) != 0)
goto done;
if (cmd == DEL_TARGET) {
err = target_del(id);
goto done;
}
target = target_lookup_by_id(id);
if (cmd == ADD_TARGET)
if (target) {
err = -EEXIST;
eprintk("Target %u already exist!\n", id);
goto done;
}
switch (cmd) {
case ADD_TARGET:
assert(!target);
err = add_target(arg);
goto done;
}
if (!target) {
eprintk("can't find the target %u\n", id);
err = -EINVAL;
goto done;
}
if ((err = target_lock(target, 1)) < 0) {
eprintk("interrupted %ld %d\n", err, cmd);
goto done;
}
switch (cmd) {
case ADD_VOLUME:
err = add_volume(target, arg);
break;
case DEL_VOLUME:
err = del_volume(target, arg);
break;
case ADD_SESSION:
err = add_session(target, arg);
break;
case DEL_SESSION:
err = del_session(target, arg);
break;
case GET_SESSION_INFO:
err = get_session_info(target, arg);
break;
case ISCSI_PARAM_SET:
err = iscsi_param_config(target, arg, 1);
break;
case ISCSI_PARAM_GET:
err = iscsi_param_config(target, arg, 0);
break;
case ADD_CONN:
err = add_conn(target, arg);
break;
case DEL_CONN:
err = del_conn(target, arg);
break;
case GET_CONN_INFO:
err = get_conn_info(target, arg);
break;
}
if (target)
target_unlock(target);
done:
return err;
}
int main(int argc,char **argv)
{
int n;
int curr_arg;
bool bDebug;
bool bNoSort;
int session_ix;
FILE *fptr;
int line_len;
int set_size;
int chara;
int *sort_ixs;
int retval;
char *cpt;
int num_rebounds;
int in_losing_streak;
int rebound_ix;
int cumulative_loss;
int cumulative_gain;
int work;
if ((argc < 2) || (argc > 4)) {
printf(usage);
return 1;
}
bDebug = false;
bNoSort = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-debug"))
bDebug = true;
else if (!strcmp(argv[curr_arg],"-no_sort"))
bNoSort = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
set_size = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
set_size++;
}
if ((session_info = (struct session_info_struct *)malloc(
set_size * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,set_size);
fclose(fptr);
return 4;
}
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix]);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
return 5;
}
session_ix++;
}
fclose(fptr);
num_rebounds = 0;
in_losing_streak = 0;
for (n = 0; n < set_size; n++) {
if (in_losing_streak) {
if (session_info[n].delta > 0) {
num_rebounds++;
if (bDebug)
printf("%3d\n",n);
for (n++; n < set_size; n++) {
if (session_info[n].delta < 0)
break;
}
}
continue;
}
else {
if (session_info[n].delta < 0)
in_losing_streak = 1;
continue;
}
}
if (bDebug)
printf("num_rebounds = %d\n",num_rebounds);
if ((rebound = (struct rebound_struct *)malloc(
num_rebounds * sizeof (struct rebound_struct))) == NULL) {
printf(malloc_failed2,num_rebounds);
fclose(fptr);
return 6;
}
if ((sort_ixs = (int *)malloc(
num_rebounds * sizeof (int))) == NULL) {
printf(malloc_failed3,num_rebounds);
fclose(fptr);
return 7;
}
rebound_ix = 0;
cumulative_loss = 0;
cumulative_gain = 0;
in_losing_streak = 0;
for (n = 0; n < set_size; n++) {
if (in_losing_streak) {
if (session_info[n].delta > 0) {
cumulative_gain = session_info[n].delta;
if (bDebug)
printf("%3d\n",n);
for (n++; n < set_size; n++) {
if (session_info[n].delta < 0)
break;
else
cumulative_gain += session_info[n].delta;
}
rebound[rebound_ix].poker_session_date =
session_info[n-1].poker_session_date;
work = cumulative_loss * -1;
if (work > cumulative_gain)
work = cumulative_gain;
rebound[rebound_ix++].rebound = work;
cumulative_loss = session_info[n].delta;
}
else
cumulative_loss += session_info[n].delta;
continue;
}
else {
if (session_info[n].delta < 0) {
in_losing_streak = 1;
cumulative_loss = session_info[n].delta;
}
continue;
}
}
for (n = 0; n < num_rebounds; n++)
sort_ixs[n] = n;
if (!bNoSort)
qsort(sort_ixs,num_rebounds,sizeof (int),elem_compare);
for (n = 0; n < num_rebounds; n++) {
cpt = ctime(&rebound[sort_ixs[n]].poker_session_date);
printf("%s %10d\n",
format_date(cpt),rebound[sort_ixs[n]].rebound);
}
free(session_info);
free(sort_ixs);
return 0;
}
int
main (int argc, char **argv)
{
gchar *confdir;
gchar *host = g_strdup ("localhost");
gchar *port = g_strdup ("22");
gchar *sshkey = NULL;
gchar *user = NULL;
gchar *password = NULL;
gchar *session = g_strdup ("thinnx");
gchar *type = g_strdup ("unix-gnome");
gchar *cookie = NULL;
gboolean use_ssl = 0;
gchar *link = g_strdup ("adsl");
gchar *kbdtype = g_strdup ("pc104/us");
gchar *geometry = g_strdup ("fullscreen");
gchar *screeninfo = NULL;
gchar *session_id = NULL;
gchar *session_display = NULL;
gchar *pcookie = NULL;
gchar **nxssh_argv = (gchar**) g_malloc (sizeof(gchar*) * 9);
gchar *restore_id = NULL;
pid_t pid;
int parent_pipe[2]; /* For talking to the parent */
int child_pipe[2]; /* For talking to the child */
gint in = 0, out = 0;
gtk_init (&argc, &argv);
homedir = g_get_home_dir ();
confdir = g_strdup_printf ("%s/.nx/", homedir);
sshkey = g_strdup_printf ("%s/.ssh/id_dsa", homedir);
{
struct stat info;
if (stat (confdir, &info) == -1)
{
if (mkdir (confdir, 0777) == -1)
g_critical ("Could not create directory %s: %s\n",
confdir, strerror (errno));
}
}
{
#if GTK_MAJOR_VERSION == 2
GdkScreen *screen;
screen = gdk_screen_get_default ();
screeninfo = g_strdup_printf ("%dx%dx%d+render",
gdk_screen_get_width (screen),
gdk_screen_get_height (screen),
gdk_visual_get_best_depth ());
#else
screeninfo = g_strdup_printf ("%dx%dx%d+render",
gdk_screen_width (),
gdk_screen_height (),
gdk_visual_get_best_depth ());
#endif
}
{ /* get X authentication cookie information */
FILE *xauth_output;
gchar xauth[256] = {0};
gchar *tmp = NULL;
gchar **tmpv = NULL;
gchar *display = NULL;
/* avoid problems with "network" DISPLAY's */
display = g_strdup (getenv ("DISPLAY"));
tmpv = g_strsplit (display, ":", 3);
g_free (display);
display = g_strdup_printf (":%s", tmpv[1]);
g_strfreev (tmpv);
/* get the authorization token */
tmp = g_strdup_printf (XAUTHBINDIR"/xauth list %s | "
"grep 'MIT-MAGIC-COOKIE-1' | "
"cut -d ' ' -f 5",
display);
if ((xauth_output = popen (tmp, "r")) == NULL)
{
g_critical ("Failed to obtain xauth key: %s", strerror(errno));
exit (1);
}
fread (xauth, sizeof(char), 256, xauth_output);
xauth[strlen(xauth) - 1] = '\0';
pclose (xauth_output);
g_free (tmp);
if (!strcmp (xauth, ""))
{
message_dialog ("Não foi possível obter um cookie de autenticação\n"
"do servidor X. Impossível continuar.");
exit (1);
}
cookie = g_strdup (xauth);
}
{ /* read configuration file */
FILE *fconf;
gint fconf_fd;
gchar **tmp, *key, *value;
struct stat info;
if (stat (CONFFILE, &info) == -1)
{
g_warning ("WARNING: Could not stat %s: %s.\n",
CONFFILE, strerror (errno));
}
fconf = fopen (CONFFILE, "r");
if (fconf == NULL)
{
g_critical ("Could not open %s: %s.\n",
CONFFILE, strerror (errno));
}
else
{
fconf_fd = fileno (fconf);
while (!feof (fconf))
{
buffer = read_line (fconf_fd);
if (!buffer)
break;
/* remove comments */
tmp = g_strsplit (buffer, "#", 2);
g_free (buffer);
buffer = g_strdup (tmp[0]);
g_strfreev (tmp);
/* check if we still have a key/value pair */
tmp = g_strsplit (buffer, "=", 2);
g_free (buffer);
if (tmp[1] == NULL || tmp[0] == NULL)
{
g_strfreev (tmp);
continue;
}
key = tmp[0];
value = tmp[1];
g_strstrip (key);
g_strstrip (value);
if (!strcmp ("host", key))
{
g_free (host);
host = g_strdup (value);
}
else if (!strcmp ("port", key))
{
g_free (port);
port = g_strdup (value);
}
else if (!strcmp ("sshkey", key))
{
g_free (sshkey);
sshkey = g_strdup (value);
}
else if (!strcmp ("session", key))
{
g_free (session);
session = g_strdup (value);
}
else if (!strcmp ("ssl", key))
{
if (!strcmp (value, "yes"))
use_ssl = 1;
}
else if (!strcmp ("type", key))
{
g_free (type);
type = g_strdup (value);
}
else if (!strcmp ("link", key))
{
g_free (link);
link = g_strdup (value);
}
else if (!strcmp ("kbdtype", key))
{
g_free (kbdtype);
kbdtype = g_strdup (value);
}
else if (!strcmp ("geometry", key))
{
g_free (geometry);
geometry = g_strdup (value);
}
else
g_warning ("Unknown option in %s: %s=%s\n",
CONFFILE, key, value);
g_strfreev (tmp);
}
fclose (fconf);
}
}
/* grab auth information from the user before anything else */
input_dialog (&user, &password);
if (!strcmp (user, "root"))
{
message_dialog ("O usuário root não pode entrar por aqui!");
exit (1);
}
pipe (parent_pipe);
pipe (child_pipe);
pid = fork ();
if (pid == -1)
{
g_critical ("Could not fork!\n");
exit (1);
}
else if (pid == 0)
{
close (child_pipe[1]);
dup2 (child_pipe[0], STDIN_FILENO);
dup2 (parent_pipe[1], STDOUT_FILENO);
nxssh_argv[0] = g_strdup (BINDIR"/nxssh");
nxssh_argv[1] = g_strdup ("-nx");
nxssh_argv[2] = g_strdup_printf ("-p%s", port);
nxssh_argv[3] = g_strdup ("-i");
nxssh_argv[4] = g_strdup (sshkey);
nxssh_argv[5] = g_strdup_printf ("nx@%s", host);
nxssh_argv[6] = g_strdup ("-2");
nxssh_argv[7] = g_strdup ("-S");
nxssh_argv[8] = NULL;
execv (nxssh_argv[0], nxssh_argv);
}
else
{
close(parent_pipe[1]);
out = parent_pipe[0];
in = child_pipe[1];
/* Handle initial hand-shaking */
{
gboolean ssh_authed = FALSE;
while (!ssh_authed)
{
buffer = read_code (out);
if (!strcmp (buffer, "NX> 205"))
{
flush_buffer (buffer);
drop_line (out);
drop_line (out);
drop_chars (out, 56);
write_line (in, "yes");
drop_line (out);
drop_line (out);
/* buffer != NULL? but why?! */
buffer = NULL;
}
else if (!strcmp (buffer, "NX> 208"))
{
/* OK, authenticating... */
}
else if (!strcmp (buffer, "NX> 203") ||
(!strcmp (buffer, "NX> 285")) ||
(!strcmp (buffer, "NX> 200")) ||
(!strcmp (buffer, "NX> 202")))
{
/* ignored stderr */
}
else if (!strncmp (buffer, "nxssh", 5))
{
gchar *msg;
flush_buffer (buffer);
buffer = read_line (out);
msg = get_info_after_colon (buffer);
g_free (buffer);
if (!strcmp (msg, "Name or service not known"))
message_dialog ("Não foi possível resolver o nome do servidor.");
else if (!strcmp (msg, "Connection refused"))
message_dialog ("A conexão foi recusada!\n"
"Verifique a porta.");
else if (!strcmp (msg, "Connection timed out"))
message_dialog ("Tempo limite da conexão expirou!\n"
"Verifique servidor e porta.");
flush_buffer (msg);
fprintf (stderr, "\n");
exit (1);
}
else if (!strcmp (buffer, "NX> 204"))
{
message_dialog ("Falha na autenticação inicial!\n"
"Confira a chave privada.");
g_critical ("Failed to authenticate to SSH using the public key!\n");
exit (1);
}
else if (!strcmp (buffer, "HELLO N"))
{
/* OK, time to say HELLO! */
ssh_authed = TRUE;
}
else
protocol_error ("problems waiting for HELLO");
flush_buffer (buffer);
buffer = read_line (out);
flush_buffer (buffer);
}
}
/* Handle HELLO */
buffer = read_code (out);
if (!strcmp (buffer, "NX> 105"))
{
flush_buffer (buffer);
drop_chars (out, 1);
write_line (in, "HELLO NXCLIENT - Version 1.4.0");
drop_line (out);
}
else
protocol_error ("problems during HELLO");
/* Handle Login */
buffer = read_code (out);
if (!strcmp (buffer, "NX> 134"))
{
flush_buffer (buffer);
buffer = read_line (out);
flush_buffer (buffer);
}
else
protocol_error ("HELLO failed?");
buffer = read_code (out);
if (!strcmp (buffer, "NX> 105"))
{
flush_buffer (buffer);
drop_chars (out, 1);
write_line (in, "login");
drop_line (out);
}
else
protocol_error ("No login? How come!");
buffer = read_code (out);
if (!strcmp (buffer, "NX> 101"))
{
flush_buffer (buffer);
drop_chars (out, 7);
write_line (in, user);
drop_line (out);
}
else
protocol_error ("who took my login prompt away?");
buffer = read_code (out);
if (!strcmp (buffer, "NX> 102"))
{
flush_buffer (buffer);
drop_chars (out, 11);
write_line (in, password);
drop_line (out);
}
else
protocol_error ("where is my password prompt?");
buffer = read_code (out);
if (!strcmp (buffer, "NX> 103"))
{
flush_buffer (buffer);
drop_line (out);
}
else
{
flush_buffer (buffer);
message_dialog ("Login ou senha incorretos!");
exit (1);
}
buffer = read_code (out);
if (!strcmp (buffer, "NX> 105"))
{
gchar *m;
flush_buffer (buffer);
drop_chars (out, 1);
m = g_strdup_printf ("list %s", user);
write_line (in, m);
g_free (m);
drop_lines (out, 5);
while (1)
{
buffer = read_code (out);
if (!strcmp (buffer, "NX> 105"))
{
flush_buffer (buffer);
drop_chars (out, 1);
break;
}
flush_buffer (buffer);
buffer = read_line (out);
restore_id = get_restore_id (buffer);
}
}
else
protocol_error ("session startup, buddy, I don't want problems!");
{
gchar *cmdline;
if (!restore_id)
cmdline = g_strdup_printf ("startsession --session=\"%s\" --type=\"%s\" --cache=\"8M\" --images=\"32M\" --cookie=\"%s\" --link=\"%s\" --kbtype=\"%s\" --nodelay=\"1\" --backingstore=\"never\" --geometry=\"%s\" --media=\"0\" --agent_server=\"\" --agent_user=\"\" --agent_password=\"\" --screeninfo=\"%s\" --encryption=\"%d\"", session, type, cookie, link, kbdtype, geometry, screeninfo, use_ssl);
else
cmdline = g_strdup_printf ("restoresession --session=\"%s\" --type=\"%s\" --cache=\"8M\" --images=\"32M\" --cookie=\"%s\" --link=\"%s\" --kbtype=\"%s\" --nodelay=\"1\" --backingstore=\"never\" --geometry=\"%s\" --media=\"0\" --agent_server=\"\" --agent_user=\"\" --agent_password=\"\" --screeninfo=\"%s\" --encryption=\"%d\" --id=\"%s\"", session, type, cookie, link, kbdtype, geometry, screeninfo, use_ssl, restore_id);
write_line (in, cmdline);
g_free (cmdline);
cmdline = NULL;
drop_lines (out, 4);
}
session_id = get_session_info (out, "NX> 700");
session_display = get_session_info (out, "NX> 705");
drop_line (out); /* 703 (session type) */
pcookie = get_session_info (out, "NX> 701");
drop_line (out); /* 702 proxy ip */
drop_line (out); /* 706 agent cookie */
drop_line (out); /* 704 session cache */
{
gchar *tmp = get_session_info (out, "NX> 707"); /* 707 ssl tunneling */
use_ssl = atoi (tmp);
g_free (tmp);
}
drop_line (out); /* 710 session status: running */
drop_line (out); /* 1002 commit */
drop_line (out); /* 1006 session status: running */
read_code (out);
drop_chars (out, 1);
/* now prepare to run nxproxy */
{
FILE *options;
gchar *dirname;
gchar *fname;
gchar *cmdline;
dirname = g_strdup_printf ("%s/.nx/S-%s", homedir, session_id);
fname = g_strdup_printf ("%s/options", dirname);
g_print ("Dir: %s\nFname: %s\n", dirname, fname);
if (mkdir (dirname, 0777) == -1)
{
/* BOMB or handle 'directory already exists' */
}
g_free (dirname);
if (use_ssl)
buffer = g_strdup_printf ("cookie=%s,root=%s/.nx,session=%s,id=%s,listen=%d:%s", pcookie, homedir, session, session_id, 8008, session_display);
else
buffer = g_strdup_printf ("cookie=%s,root=%s/.nx,session=%s,id=%s,connect=%s:%s", pcookie, homedir, session, session_id, host, session_display);
options = fopen (fname, "w");
fwrite (buffer, sizeof(char), strlen (buffer), options);
fclose (options);
g_free (buffer);
cmdline = g_strdup_printf (BINDIR"/nxproxy -S options=%s:%s", fname, session_display);
system (cmdline);
g_free (cmdline);
g_free (fname);
}
}
write_line (in, "bye");
drop_line (out);
if (use_ssl)
write_line (in, "switch");
drop_line (out);
drop_line (out);
drop_line (out);
return 0;
}
int main(int argc,char **argv)
{
int m;
int n;
bool bNoSort;
int ge_sum;
int curr_arg;
int session_ix;
FILE *fptr;
int line_len;
int set_size;
int chara;
int *sort_ixs;
int num_sums;
int sum;
int num_winning_sessions;
int retval;
char *cpt;
if ((argc < 2) || (argc > 4)) {
printf(usage);
return 1;
}
bNoSort = false;
bAscending = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-no_sort"))
bNoSort = true;
else if (!strcmp(argv[curr_arg],"-ascending"))
bAscending = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
set_size = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
set_size++;
}
if ((session_info = (struct session_info_struct *)malloc(
set_size * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,set_size);
fclose(fptr);
return 4;
}
if ((sort_ixs = (int *)malloc(
set_size * sizeof (int))) == NULL) {
printf(malloc_failed2,set_size);
fclose(fptr);
return 5;
}
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix],
session_ix);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
return 6;
}
sort_ixs[session_ix] = session_ix;
session_ix++;
}
for (n = 0; n < set_size - 2; n++) {
for (m = set_size - 1; m > n + 1; m--) {
if ((session_info[m].ending_amount > session_info[n].ending_amount) &&
(session_info[m-1].ending_amount < session_info[n].ending_amount))
break;
}
if (m > n + 1) {
session_info[n].max_underwater_length = m - 1 - n;
session_info[n].end_date = session_info[m].start_date;
session_info[n].end_ix = session_info[m].start_ix;
}
}
if (!bNoSort)
qsort(sort_ixs,set_size,sizeof (int),elem_compare);
for (n = 0; n < set_size; n++) {
if (session_info[sort_ixs[n]].max_underwater_length != -1) {
printf("%3d ",session_info[sort_ixs[n]].max_underwater_length);
cpt = ctime(&session_info[sort_ixs[n]].start_date);
printf("%s ",format_date(cpt));
cpt = ctime(&session_info[sort_ixs[n]].end_date);
printf("%s (%d %d)\n",format_date(cpt),
session_info[sort_ixs[n]].start_ix,
session_info[sort_ixs[n]].end_ix);
}
}
fclose(fptr);
free(session_info);
free(sort_ixs);
return 0;
}
static long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
struct iscsi_target *target = NULL;
long err;
u32 id;
err = down_interruptible(&ioctl_sem);
if (err < 0)
return err;
if (cmd == GET_MODULE_INFO) {
err = get_module_info(arg);
goto done;
}
if (cmd == ADD_TARGET) {
err = add_target(arg);
goto done;
}
err = get_user(id, (u32 *) arg);
if (err < 0)
goto done;
/* locking handled in target_del */
if (cmd == DEL_TARGET) {
err = target_del(id);
goto done;
}
target = target_lookup_by_id(id);
if (!target) {
err = -ENOENT;
goto done;
}
err = target_lock(target, 1);
if (err < 0)
goto done;
switch (cmd) {
case ADD_VOLUME:
err = add_volume(target, arg);
break;
case DEL_VOLUME:
err = del_volume(target, arg);
break;
case ADD_SESSION:
err = add_session(target, arg);
break;
case DEL_SESSION:
err = del_session(target, arg);
break;
case GET_SESSION_INFO:
err = get_session_info(target, arg);
break;
case ISCSI_PARAM_SET:
err = iscsi_param_config(target, arg, 1);
break;
case ISCSI_PARAM_GET:
err = iscsi_param_config(target, arg, 0);
break;
case ADD_CONN:
err = add_conn(target, arg);
break;
case DEL_CONN:
err = del_conn(target, arg);
break;
case GET_CONN_INFO:
err = get_conn_info(target, arg);
break;
default:
eprintk("invalid ioctl cmd %x\n", cmd);
err = -EINVAL;
}
target_unlock(target);
done:
up(&ioctl_sem);
return err;
}
int main(int argc,char **argv)
{
int m;
int n;
bool bNoSort;
bool bNot;
int curr_arg;
FILE *fptr;
int line_len;
int num_sessions;
int session_ix;
int delta;
int session_is_blue;
int prev_session_is_blue;
int chara;
int *sort_ixs;
int num_blue_streaks;
int blue_streak_ix;
int retval;
char *cpt;
int cumulative_delta;
int max_cumulative_delta;
if ((argc < 2) || (argc > 5)) {
printf(usage);
return 1;
}
bNoSort = false;
bAscending = false;
bNot = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-no_sort"))
bNoSort = true;
else if (!strcmp(argv[curr_arg],"-ascending"))
bAscending = true;
else if (!strcmp(argv[curr_arg],"-not"))
bNot = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
num_sessions = 0;
num_blue_streaks = 0;
cumulative_delta = 0;
max_cumulative_delta = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
sscanf(&line[11],"%d",&delta);
cumulative_delta += delta;
if (cumulative_delta > max_cumulative_delta) {
if (!bNot)
session_is_blue = 1;
else
session_is_blue = 0;
max_cumulative_delta = cumulative_delta;
}
else {
if (!bNot)
session_is_blue = 0;
else
session_is_blue = 1;
}
if ((session_is_blue == 1) && ((num_sessions == 0) || (prev_session_is_blue == 0)))
num_blue_streaks++;
num_sessions++;
prev_session_is_blue = session_is_blue;
}
if ((session_info = (struct session_info_struct *)malloc(
num_sessions * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_sessions);
fclose(fptr);
return 4;
}
if ((blue_streaks = (struct session_info_struct *)malloc(
num_blue_streaks * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_blue_streaks);
fclose(fptr);
free(session_info);
return 5;
}
if ((sort_ixs = (int *)malloc(
num_blue_streaks * sizeof (int))) == NULL) {
printf(malloc_failed2,num_blue_streaks);
fclose(fptr);
free(session_info);
free(blue_streaks);
return 6;
}
for (n = 0; n < num_blue_streaks; n++)
sort_ixs[n] = n;
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
cumulative_delta = 0;
max_cumulative_delta = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix]);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
fclose(fptr);
free(session_info);
free(blue_streaks);
free(sort_ixs);
return 7;
}
cumulative_delta += session_info[session_ix].delta;
if (cumulative_delta > max_cumulative_delta) {
if (!bNot)
session_info[session_ix].session_is_blue = 1;
else
session_info[session_ix].session_is_blue = 0;
max_cumulative_delta = cumulative_delta;
}
else {
if (!bNot)
session_info[session_ix].session_is_blue = 0;
else
session_info[session_ix].session_is_blue = 1;
}
if ((session_info[session_ix].session_is_blue == 1) &&
((session_ix == 0) || (session_info[session_ix-1].session_is_blue == 0)))
session_info[session_ix].session_starts_blue_streak = 1;
else
session_info[session_ix].session_starts_blue_streak = 0;
session_ix++;
}
fclose(fptr);
blue_streak_ix = 0;
for (n = 0; n < num_sessions; n++) {
if (session_info[n].session_starts_blue_streak) {
blue_streaks[blue_streak_ix].start_date = session_info[n].start_date;
blue_streaks[blue_streak_ix].sum = session_info[n].delta;
for (m = n + 1; (m < num_sessions) && (session_info[m].session_is_blue == 1); m++)
blue_streaks[blue_streak_ix].sum += session_info[m].delta;
blue_streaks[blue_streak_ix].end_date = session_info[m - 1].start_date;
blue_streaks[blue_streak_ix].num_blue_sessions = m - n;
blue_streak_ix++;
}
}
if (!bNoSort)
qsort(sort_ixs,num_blue_streaks,sizeof (int),elem_compare);
for (n = 0; n < num_blue_streaks; n++) {
printf("%3d ",blue_streaks[sort_ixs[n]].num_blue_sessions);
cpt = ctime(&blue_streaks[sort_ixs[n]].start_date);
printf("%s ",format_date(cpt));
cpt = ctime(&blue_streaks[sort_ixs[n]].end_date);
printf("%s ",format_date(cpt));
printf("%10d\n",blue_streaks[sort_ixs[n]].sum);
}
free(session_info);
free(blue_streaks);
free(sort_ixs);
return 0;
}
int iet_ioctl(struct cdev *dev, unsigned long cmd, caddr_t iarg, int fflag, struct thread *td)
#endif
{
struct iscsi_target *target = NULL;
long err;
u32 id;
#ifdef FREEBSD
unsigned long arg = (unsigned long)(iarg); /* Avoid make warnings */
#endif
err = mutex_lock_interruptible(&ioctl_mutex);
if (err != 0)
return err;
if (cmd == GET_MODULE_INFO) {
err = get_module_info(arg);
goto done;
}
if (cmd == ADD_TARGET) {
err = add_target(arg);
goto done;
}
err = copy_from_user(&id, (u32 *) (unsigned long)arg, sizeof(u32));
if (err < 0)
goto done;
/* locking handled in target_del */
if (cmd == DEL_TARGET) {
err = target_del(id);
goto done;
}
target = target_lookup_by_id(id);
if (!target) {
err = -ENOENT;
goto done;
}
err = target_lock(target, 1);
if (err < 0)
goto done;
switch (cmd) {
case ADD_VOLUME:
err = add_volume(target, arg);
break;
case DEL_VOLUME:
err = del_volume(target, arg);
break;
case ADD_SESSION:
err = add_session(target, arg);
break;
case DEL_SESSION:
err = del_session(target, arg);
break;
case GET_SESSION_INFO:
err = get_session_info(target, arg);
break;
case ISCSI_PARAM_SET:
err = iscsi_param_config(target, arg, 1);
break;
case ISCSI_PARAM_GET:
err = iscsi_param_config(target, arg, 0);
break;
case ADD_CONN:
err = add_conn(target, arg);
break;
case DEL_CONN:
err = del_conn(target, arg);
break;
case GET_CONN_INFO:
err = get_conn_info(target, arg);
break;
default:
eprintk("invalid ioctl cmd %lx\n", (unsigned long)cmd);
err = -EINVAL;
}
target_unlock(target);
done:
mutex_unlock(&ioctl_mutex);
#ifdef FREEBSD
if (err < 0)
err = -(err);
#endif
return err;
}
int main(int argc,char **argv)
{
int m;
int n;
bool bNoSort;
bool bTotal;
int curr_arg;
FILE *fptr;
int line_len;
int num_sessions;
int session_ix;
int delta;
int prev_delta;
int chara;
int *sort_ixs;
int num_losing_streaks;
int losing_streak_ix;
int retval;
char *cpt;
int total_losing_sessions;
int total_losing_session_deltas;
if ((argc < 2) || (argc > 6)) {
printf(usage);
return 1;
}
bNoSort = false;
bTotal = false;
bAscending = false;
bSortBySumDelta = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-no_sort"))
bNoSort = true;
else if (!strcmp(argv[curr_arg],"-ascending"))
bAscending = true;
else if (!strcmp(argv[curr_arg],"-sort_by_sum_delta"))
bSortBySumDelta = true;
else if (!strcmp(argv[curr_arg],"-total"))
bTotal = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
num_sessions = 0;
num_losing_streaks = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
sscanf(&line[11],"%d",&delta);
if ((delta < 0) && ((num_sessions == 0) || (prev_delta > 0)))
num_losing_streaks++;
num_sessions++;
prev_delta = delta;
}
if ((session_info = (struct session_info_struct *)malloc(
num_sessions * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_sessions);
fclose(fptr);
return 4;
}
if ((losing_streaks = (struct session_info_struct *)malloc(
num_losing_streaks * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_losing_streaks);
fclose(fptr);
free(session_info);
return 5;
}
if ((sort_ixs = (int *)malloc(
num_losing_streaks * sizeof (int))) == NULL) {
printf(malloc_failed2,num_losing_streaks);
fclose(fptr);
free(session_info);
free(losing_streaks);
return 6;
}
for (n = 0; n < num_losing_streaks; n++)
sort_ixs[n] = n;
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix]);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
fclose(fptr);
free(session_info);
free(losing_streaks);
free(sort_ixs);
return 7;
}
session_ix++;
}
fclose(fptr);
losing_streak_ix = 0;
for (n = 0; n < num_sessions; n++) {
if ((session_info[n].delta < 0) && ((n == 0) || (session_info[n-1].delta > 0))) {
losing_streaks[losing_streak_ix].start_date = session_info[n].start_date;
losing_streaks[losing_streak_ix].sum = session_info[n].delta;
for (m = n + 1; (m < num_sessions) && (session_info[m].delta < 0); m++)
losing_streaks[losing_streak_ix].sum += session_info[m].delta;
losing_streaks[losing_streak_ix].end_date = session_info[m - 1].start_date;
losing_streaks[losing_streak_ix].num_losing_sessions = m - n;
losing_streak_ix++;
}
}
if (!bNoSort)
qsort(sort_ixs,num_losing_streaks,sizeof (int),elem_compare);
if (bTotal) {
total_losing_sessions = 0;
total_losing_session_deltas = 0;
}
for (n = 0; n < num_losing_streaks; n++) {
printf("%3d ",losing_streaks[sort_ixs[n]].num_losing_sessions);
cpt = ctime(&losing_streaks[sort_ixs[n]].start_date);
printf("%s ",format_date(cpt));
cpt = ctime(&losing_streaks[sort_ixs[n]].end_date);
printf("%s ",format_date(cpt));
printf("%10d\n",losing_streaks[sort_ixs[n]].sum);
if (bTotal) {
total_losing_sessions += losing_streaks[sort_ixs[n]].num_losing_sessions;
total_losing_session_deltas += losing_streaks[sort_ixs[n]].sum;
}
}
free(session_info);
free(losing_streaks);
free(sort_ixs);
if (bTotal) {
printf("\n%3d %10d\n",
total_losing_sessions,total_losing_session_deltas);
}
return 0;
}
int main(int argc,char **argv)
{
int m;
int n;
int p;
int curr_arg;
bool bVerbose;
FILE *fptr;
int line_len;
int num_sessions;
int work;
int wins;
int losses;
double winpct;
double max_winpct;
int max_wins;
int max_winpct_ix;
int num_max_winpcts;
int *sort_ixs;
int ix;
int retval;
char *cpt;
if ((argc < 2) || (argc > 3)) {
printf(usage);
return 1;
}
bVerbose = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-verbose"))
bVerbose = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
num_sessions = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
num_sessions++;
}
fseek(fptr,0L,SEEK_SET);
if ((session_info = (struct session_info_struct *)malloc(
num_sessions * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_sessions);
fclose(fptr);
return 4;
}
ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
retval = get_session_info(line,line_len,&session_info[ix]);
session_info[ix].num_max_winpct_sessions = -1;
session_info[ix].starting_ix = ix;
ix++;
}
fclose(fptr);
for (m = 0; m < num_sessions; m++) {
max_winpct = (double)0;
for (n = m + 1; n < num_sessions; n++) {
wins = 0;
losses = 0;
for (p = m; p <= n; p++) {
if (session_info[p].delta > 0)
wins++;
else if (session_info[p].delta < 0)
losses++;
}
if ((wins > 0) && (losses > 0)) {
winpct = (double)wins / (double)(n - m + 1);
if (winpct > max_winpct) {
max_winpct = winpct;
max_wins = wins;
max_winpct_ix = n;
}
}
}
if (max_winpct > (double)0) {
session_info[m].num_max_winpct_wins = max_wins;
session_info[m].num_max_winpct_sessions = max_winpct_ix - m + 1;
session_info[m].max_winpct = max_winpct;
session_info[m].max_winpct_end_date = session_info[max_winpct_ix].max_winpct_start_date;
}
}
num_max_winpcts = 0;
for (n = 0; n < num_sessions; n++) {
if (session_info[n].num_max_winpct_sessions != -1) {
if (num_max_winpcts != n)
session_info[num_max_winpcts] = session_info[n];
num_max_winpcts++;
}
}
if ((sort_ixs = (int *)malloc(
num_max_winpcts * sizeof (int))) == NULL) {
printf(malloc_failed2,num_max_winpcts);
fclose(fptr);
return 5;
}
for (n = 0; n < num_max_winpcts; n++)
sort_ixs[n] = n;
qsort(sort_ixs,num_max_winpcts,sizeof (int),elem_compare);
for (n = 0; n < num_max_winpcts; n++) {
printf(fmt1,
session_info[sort_ixs[n]].starting_ix);
cpt = ctime(&session_info[sort_ixs[n]].max_winpct_start_date);
printf("%s\n",format_date(cpt));
printf(fmt1,
session_info[sort_ixs[n]].starting_ix +
session_info[sort_ixs[n]].num_max_winpct_sessions - 1);
cpt = ctime(&session_info[sort_ixs[n]].max_winpct_end_date);
printf("%s\n",format_date(cpt));
printf(fmt2,
session_info[sort_ixs[n]].num_max_winpct_sessions,
session_info[sort_ixs[n]].max_winpct,
session_info[sort_ixs[n]].num_max_winpct_wins);
if (!bVerbose)
break;
if (n < num_max_winpcts - 1)
putchar(0x0a);
}
free(session_info);
free(sort_ixs);
return 0;
}
int main(int argc,char **argv)
{
int m;
int n;
bool bDebug;
bool bSort;
int curr_arg;
int session_ix;
FILE *fptr;
int line_len;
int num_sessions;
int chara;
int *sort_ixs;
int retval;
char *cpt;
int num_condensed_sessions;
int condensed_ix;
if ((argc < 2) || (argc > 3)) {
printf(usage);
return 1;
}
bDebug = false;
bSort = false;
bAscending = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-debug"))
bDebug = true;
else if (!strcmp(argv[curr_arg],"-sort"))
bSort = true;
else if (!strcmp(argv[curr_arg],"-ascending"))
bAscending = true;
else
break;
}
if (argc - curr_arg != 1) {
printf(usage);
return 2;
}
if ((fptr = fopen(argv[curr_arg],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg]);
return 3;
}
num_sessions = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
num_sessions++;
}
if ((session_info = (struct session_info_struct *)malloc(
num_sessions * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,num_sessions);
fclose(fptr);
return 4;
}
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix]);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
return 5;
}
session_info[session_ix].nobs = -1;
session_ix++;
}
fclose(fptr);
if (bDebug) {
for (n = 0; n < num_sessions; n++) {
cpt = ctime(&session_info[n].start_date);
cpt[strlen(cpt) - 1] = 0;
printf("%s %10d\n",cpt,session_info[n].delta);
}
}
n = 0;
num_condensed_sessions = 0;
for ( ; ; ) {
session_info[n].sum = session_info[n].delta;
for (m = n + 1; m < num_sessions; m++) {
if (session_info[n].delta < 0) {
if (session_info[m].delta < 0)
session_info[n].sum += session_info[m].delta;
else
break;
}
else {
if (session_info[m].delta > 0)
session_info[n].sum += session_info[m].delta;
else
break;
}
}
num_condensed_sessions++;
session_info[n].nobs = m - n;
session_info[n].end_date = session_info[m - 1].start_date;
if (m == num_sessions)
break;
n = m;
}
condensed_ix = 0;
for (n = 0; n < num_sessions; n++) {
if (session_info[n].nobs != -1) {
if (condensed_ix != n)
session_info[condensed_ix] = session_info[n];
condensed_ix++;
}
}
if ((sort_ixs = (int *)malloc(
num_condensed_sessions * sizeof (int))) == NULL) {
printf(malloc_failed2,num_condensed_sessions);
fclose(fptr);
return 6;
}
for (n = 0; n < num_condensed_sessions; n++)
sort_ixs[n] = n;
if (bSort)
qsort(sort_ixs,num_condensed_sessions,sizeof (int),elem_compare);
for (n = 0; n < num_condensed_sessions; n++) {
printf("%10d ",session_info[sort_ixs[n]].sum);
cpt = ctime(&session_info[sort_ixs[n]].start_date);
cpt[strlen(cpt) - 1] = 0;
printf("%s ",cpt);
cpt = ctime(&session_info[sort_ixs[n]].end_date);
cpt[strlen(cpt) - 1] = 0;
printf("%s (%3d)\n",cpt,session_info[sort_ixs[n]].nobs);
}
free(session_info);
free(sort_ixs);
return 0;
}
int main(int argc,char **argv)
{
int m;
int n;
bool bNoSort;
int curr_arg;
int session_ix;
int subset_size;
FILE *fptr;
int line_len;
int set_size;
int chara;
int *sort_ixs;
int num_churns;
int sum_deltas;
int sum_absolute_value_deltas;
double dwork;
double sum_deltas_dwork;
int num_winning_sessions;
int retval;
char *cpt;
if ((argc < 3) || (argc > 5)) {
printf(usage);
return 1;
}
bNoSort = false;
bAscending = false;
for (curr_arg = 1; curr_arg < argc; curr_arg++) {
if (!strcmp(argv[curr_arg],"-no_sort"))
bNoSort = true;
else if (!strcmp(argv[curr_arg],"-ascending"))
bAscending = true;
else
break;
}
if (argc - curr_arg != 2) {
printf(usage);
return 2;
}
sscanf(argv[curr_arg],"%d",&subset_size);
if ((fptr = fopen(argv[curr_arg+1],"r")) == NULL) {
printf(couldnt_open,argv[curr_arg+1]);
return 3;
}
set_size = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
set_size++;
}
if (subset_size > set_size) {
printf("subset_size (%d) > set_size (%d)\n",subset_size,set_size);
fclose(fptr);
return 4;
}
num_churns = set_size - subset_size + 1;
if ((session_info = (struct session_info_struct *)malloc(
set_size * sizeof (struct session_info_struct))) == NULL) {
printf(malloc_failed1,set_size);
fclose(fptr);
return 5;
}
if ((sort_ixs = (int *)malloc(
num_churns * sizeof (int))) == NULL) {
printf(malloc_failed2,num_churns);
fclose(fptr);
return 6;
}
fseek(fptr,0L,SEEK_SET);
session_ix = 0;
for ( ; ; ) {
GetLine(fptr,line,&line_len,MAX_LINE_LEN);
if (feof(fptr))
break;
if (!line_len)
continue;
chara = line[0];
if (((chara >= 'a') && (chara <= 'z')) ||
((chara >= 'A') && (chara <= 'Z')))
continue;
retval = get_session_info(line,line_len,&session_info[session_ix]);
if (retval) {
printf("get_session_info() failed on line %d: %d\n",
session_ix+1,retval);
return 7;
}
session_ix++;
}
for (n = 0; n < num_churns; n++) {
sum_deltas = 0;
sum_absolute_value_deltas = 0;
num_winning_sessions = 0;
for (m = 0; m < subset_size; m++) {
sum_deltas += session_info[n+m].delta;
if (session_info[n+m].delta > 0) {
num_winning_sessions++;
sum_absolute_value_deltas += session_info[n+m].delta;
}
else
sum_absolute_value_deltas -= session_info[n+m].delta;
}
if (sum_deltas < 0)
sum_deltas_dwork = (double)sum_deltas * (double)-1;
else
sum_deltas_dwork = (double)sum_deltas;
dwork = (double)sum_absolute_value_deltas / sum_deltas_dwork;
session_info[n].churn = dwork;
session_info[n].num_winning_sessions = num_winning_sessions;
session_info[n].end_date = session_info[n+subset_size-1].start_date;
sort_ixs[n] = n;
}
if (!bNoSort)
qsort(sort_ixs,num_churns,sizeof (int),elem_compare);
for (n = 0; n < num_churns; n++) {
printf("%13.2lf ",session_info[sort_ixs[n]].churn);
cpt = ctime(&session_info[sort_ixs[n]].start_date);
printf("%s ",format_date(cpt));
cpt = ctime(&session_info[sort_ixs[n]].end_date);
printf("%s ",format_date(cpt));
printf("(%d)\n",session_info[sort_ixs[n]].num_winning_sessions);
}
fclose(fptr);
free(session_info);
free(sort_ixs);
return 0;
}
