1 /*
2 * Argus Software
3 * Copyright (c) 2000-2016 QoSient, LLC
4 * All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2, or (at your option)
9 * any later version.
10
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 *
20 * ratop - curses (color) based argus GUI modeled after the top program.
21 *
22 * racurses.c - this module handles the curses screen input and
23 * output operations
24 *
25 * Author: Carter Bullard carter@qosient.com
26 */
27
28
29 #ifdef HAVE_CONFIG_H
30 #include "argus_config.h"
31 #endif
32
33 #if defined(CYGWIN)
34 #define USE_IPV6
35 #endif
36
37 #define RA_CURSES_MAIN
38 #include <racurses.h>
39
40
41 #if defined(ARGUS_CURSES) && defined(ARGUS_COLOR_SUPPORT)
42 int ArgusColorAvailability(struct ArgusParserStruct *, struct ArgusRecordStruct *, struct ArgusAttributeStruct *, short, attr_t);
43 int ArgusColorAddresses(struct ArgusParserStruct *, struct ArgusRecordStruct *, struct ArgusAttributeStruct *, short, attr_t);
44 int ArgusColorFlowFields(struct ArgusParserStruct *, struct ArgusRecordStruct *, struct ArgusAttributeStruct *, short, attr_t);
45 int ArgusColorGeoLocation(struct ArgusParserStruct *, struct ArgusRecordStruct *, struct ArgusAttributeStruct *, short, attr_t);
46 void ArgusInitializeColorMap(struct ArgusParserStruct *, WINDOW *);
47
48 short ArgusColorHighlight = ARGUS_WHITE;
49
50 #endif
51
52 int
main(int argc,char ** argv)53 main(int argc, char **argv)
54 {
55 struct ArgusParserStruct *parser = NULL;
56 pthread_attr_t attr;
57 int ArgusExitStatus;
58
59 ArgusThreadsInit(&attr);
60
61 if ((parser = ArgusNewParser(argv[0])) != NULL) {
62 ArgusParser = parser;
63 ArgusMainInit (parser, argc, argv);
64 ArgusClientInit (parser);
65
66 #ifdef ARGUS_CURSES
67 #if defined(ARGUS_THREADS)
68 sigset_t blocked_signals;
69
70 sigfillset(&blocked_signals);
71 sigdelset(&blocked_signals, SIGTERM);
72 sigdelset(&blocked_signals, SIGINT);
73 sigdelset(&blocked_signals, SIGWINCH);
74
75 pthread_sigmask(SIG_BLOCK, &blocked_signals, NULL);
76
77 if (ArgusCursesEnabled)
78 if ((pthread_create(&RaCursesThread, NULL, ArgusCursesProcess, NULL)) != 0)
79 ArgusLog (LOG_ERR, "ArgusCursesProcess() pthread_create error %s\n", strerror(errno));
80
81 if ((pthread_create(&RaDataThread, NULL, ArgusProcessData, NULL)) != 0)
82 ArgusLog (LOG_ERR, "main() pthread_create error %s\n", strerror(errno));
83
84 pthread_join(RaDataThread, NULL);
85 pthread_join(RaCursesThread, NULL);
86
87 ArgusWindowClose();
88 #endif
89 #endif
90 }
91
92 ArgusExitStatus = RaCursesClose(parser, &attr);
93 exit (ArgusExitStatus);
94 }
95
96
97 #if defined(ARGUS_CURSES)
98
99 int
RaCursesSetWindowFocus(struct ArgusParserStruct * parser,WINDOW * win)100 RaCursesSetWindowFocus(struct ArgusParserStruct *parser, WINDOW *win)
101 {
102 int i, cnt, retn = 0;
103 if ((cnt = ArgusWindowQueue->count) > 0) {
104 for (i = 0; i < cnt; i++) {
105 struct ArgusWindowStruct *ws = (struct ArgusWindowStruct *)ArgusPopQueue(ArgusWindowQueue, ARGUS_LOCK);
106 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
107
108 if (ws->window == win) {
109 #ifdef ARGUSDEBUG
110 ArgusDebug (1, "setting window focus to %s", ws->desc);
111 #endif
112 RaFocusWindow = win;
113 break;
114 }
115 }
116 }
117 return (retn);
118 }
119
120 WINDOW *
RaCursesGetWindowFocus(struct ArgusParserStruct * parser)121 RaCursesGetWindowFocus(struct ArgusParserStruct *parser)
122 {
123 return(RaFocusWindow);
124 }
125
126 #endif
127
128 int
RaCursesClose(struct ArgusParserStruct * parser,pthread_attr_t * attr)129 RaCursesClose(struct ArgusParserStruct *parser, pthread_attr_t *attr)
130 {
131 struct ArgusInput *addr;
132 int retn = 0;
133
134 RaParseComplete(0);
135 ArgusShutDown (0);
136
137 #if defined(ARGUS_THREADS)
138 if (parser->Sflag) {
139 void *retn = NULL;
140
141 if (parser->ArgusReliableConnection)
142 pthread_attr_destroy(attr);
143
144 while ((addr = (void *)ArgusPopQueue(parser->ArgusActiveHosts, ARGUS_LOCK)) != NULL) {
145 if (addr->tid != (pthread_t) 0) {
146 pthread_join(addr->tid, &retn);
147 }
148 }
149 }
150
151 if (parser->dns != (pthread_t) 0)
152 pthread_join(parser->dns, NULL);
153 #endif
154
155 retn = parser->ArgusExitStatus;
156 ArgusCloseParser(parser);
157 return (retn);
158 }
159
160
161 int RaInitCurses (void);
162 void RaRefreshDisplay (void);
163 void RaOutputModifyScreen (void);
164 void RaOutputHelpScreen (void);
165 void RaResizeScreen(void);
166 void ArgusCursesProcessInit(void);
167 void ArgusCursesProcessClose(void);
168 void ArgusDrawWindow(struct ArgusWindowStruct *);
169
170 int ArgusFetchWindowData(struct ArgusWindowStruct *);
171
172 #if defined(ARGUS_CURSES)
173 void RaUpdateHeaderWindow(WINDOW *);
174 void RaUpdateDebugWindow(WINDOW *);
175 void RaUpdateStatusWindow(WINDOW *);
176
177 void *
ArgusCursesProcess(void * arg)178 ArgusCursesProcess (void *arg)
179 {
180 int done = 0, cnt = 0;
181 struct timeval ntvbuf, *ntvp = &ntvbuf;
182
183 ArgusCursesProcessInit();
184
185 while (!done) {
186 struct timeval tvbuf, *tvp = &tvbuf;
187 int ArgusDisplayNeedsRefreshing = 0;
188 struct timespec tsbuf, *tsp = &tsbuf;
189
190 gettimeofday(tvp, NULL);
191
192 #if defined(ARGUS_THREADS)
193 pthread_mutex_lock(&RaCursesLock);
194 #endif
195 if (RaScreenResize == TRUE)
196 RaResizeScreen();
197
198 if ((cnt = ArgusWindowQueue->count) > 0) {
199 int i, retn;
200
201 for (i = 0; i < cnt; i++) {
202 struct ArgusWindowStruct *ws = (struct ArgusWindowStruct *)ArgusPopQueue(ArgusWindowQueue, ARGUS_LOCK);
203
204 if ((retn = ws->data(ws)) > 0) {
205 if (ws == RaDataWindowStruct) {
206 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
207
208 if (queue->status & RA_MODIFIED)
209 ArgusTouchScreen();
210
211 if (RaWindowImmediate || ((tvp->tv_sec > ntvp->tv_sec) || ((tvp->tv_sec == ntvp->tv_sec) &&
212 (tvp->tv_usec > ntvp->tv_usec)))) {
213 ArgusDrawWindow(ws);
214 ntvp->tv_sec = tvp->tv_sec + RaCursesUpdateInterval.tv_sec;
215 ntvp->tv_usec = tvp->tv_usec + RaCursesUpdateInterval.tv_usec;
216 while (ntvp->tv_usec > 1000000) {
217 ntvp->tv_sec += 1;
218 ntvp->tv_usec -= 1000000;
219 }
220 RaWindowImmediate = FALSE;
221 ArgusDisplayNeedsRefreshing = 1;
222 }
223
224 } else
225 ArgusDrawWindow(ws);
226 }
227 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
228 }
229
230 if (ArgusDisplayNeedsRefreshing) {
231 RaRefreshDisplay();
232 }
233 }
234
235 #if defined(ARGUS_THREADS)
236 pthread_mutex_unlock(&RaCursesLock);
237 #endif
238 tsp->tv_sec = 0;
239 tsp->tv_nsec = 2500000;
240 nanosleep(tsp, NULL);
241 }
242
243 ArgusCursesProcessClose();
244 pthread_exit (NULL);
245 }
246
247
248 int RaWindowPass = 1;
249
250 struct ArgusInputCommand *ArgusInputHitTable [0x200];
251
252 struct ArgusInputCommand {
253 int ch;
254 int (*process)(WINDOW *, int, int);
255 };
256
257
258
259 void ArgusProcessCursesInputInit(WINDOW *);
260 int ArgusProcessTerminator (WINDOW *, int, int);
261 int ArgusProcessNewPage (WINDOW *, int, int);
262 int ArgusProcessDeviceControl (WINDOW *, int, int);
263 int ArgusProcessEscape (WINDOW *, int, int);
264 int ArgusProcessEndofTransmission (WINDOW *, int, int);
265 int ArgusProcessKeyUp (WINDOW *, int, int);
266 int ArgusProcessKeyDown (WINDOW *, int, int);
267 int ArgusProcessKeyLeft (WINDOW *, int, int);
268 int ArgusProcessKeyRight (WINDOW *, int, int);
269 int ArgusProcessBell (WINDOW *, int, int);
270 int ArgusProcessBackspace (WINDOW *, int, int);
271 int ArgusProcessDeleteLine (WINDOW *, int, int);
272
273 int ArgusProcessCharacter(WINDOW *, int, int);
274
275 #define MAX_INPUT_OPERATORS 21
276 struct ArgusInputCommand ArgusInputCommandTable [MAX_INPUT_OPERATORS] = {
277 {0, ArgusProcessCharacter },
278 {'\n', ArgusProcessTerminator },
279 {'\r', ArgusProcessTerminator },
280 {0x07, ArgusProcessBell },
281 {0x0c, ArgusProcessNewPage },
282 {0x11, ArgusProcessDeviceControl },
283 {0x12, ArgusProcessDeviceControl },
284 {0x13, ArgusProcessDeviceControl },
285 {0x14, ArgusProcessDeviceControl },
286 {0x15, ArgusProcessDeleteLine },
287 {0x1B, ArgusProcessEscape },
288 {0x04, ArgusProcessEndofTransmission },
289 {KEY_UP, ArgusProcessKeyUp },
290 {KEY_DOWN, ArgusProcessKeyDown },
291 {KEY_LEFT, ArgusProcessKeyLeft },
292 {KEY_RIGHT, ArgusProcessKeyRight },
293 {'\b', ArgusProcessBackspace },
294 {0x7F, ArgusProcessBackspace },
295 {KEY_DC, ArgusProcessBackspace },
296 {KEY_BACKSPACE, ArgusProcessBackspace },
297 {KEY_DL, ArgusProcessDeleteLine },
298 };
299
300
301 int ArgusInputInit = 0;
302 void
ArgusProcessCursesInputInit(WINDOW * win)303 ArgusProcessCursesInputInit(WINDOW *win)
304 {
305 int i, ch;
306
307 if (ArgusInputInit++ == 0) {
308 bzero(ArgusInputHitTable, sizeof(ArgusInputHitTable));
309
310 for (i = 0; i < KEY_MAX; i++)
311 ArgusInputHitTable[i] = &ArgusInputCommandTable[0];
312
313 for (i = 1; i < MAX_INPUT_OPERATORS; i++) {
314 if ((ch = ArgusInputCommandTable[i].ch) < KEY_MAX)
315 ArgusInputHitTable[ch] = &ArgusInputCommandTable[i];
316 }
317 }
318
319 cbreak();
320
321 #if defined(ARGUS_READLINE) || defined(ARGUS_EDITLINE)
322 keypad(win, FALSE);
323 #else
324 keypad(win, TRUE);
325 #endif
326 meta(win, TRUE);
327 noecho();
328 nonl();
329
330 idlok (win, TRUE);
331 notimeout(win, TRUE);
332 nodelay(win, TRUE);
333 intrflush(win, FALSE);
334 }
335
336 void *
ArgusProcessCursesInput(void * arg)337 ArgusProcessCursesInput(void *arg)
338 {
339 struct timeval tvbuf, *tvp = &tvbuf;
340 fd_set in;
341 int ch;
342
343 ArgusProcessCursesInputInit(RaStatusWindow);
344
345 tvp->tv_sec = 0; tvp->tv_usec = 100000;
346
347 while (!ArgusCloseDown) {
348 FD_ZERO(&in); FD_SET(0, &in);
349 while (!ArgusWindowClosing && (select(1, &in, 0, 0, tvp) > 0)) {
350 if ((ch = wgetch(RaStatusWindow)) != ERR) {
351 RaInputStatus = ArgusProcessCommand (ArgusParser, RaInputStatus, ch);
352 }
353 }
354 tvp->tv_sec = 0; tvp->tv_usec = 10000;
355 }
356 pthread_exit (NULL);
357 }
358
359
360 int
ArgusProcessCommand(struct ArgusParserStruct * parser,int status,int ch)361 ArgusProcessCommand (struct ArgusParserStruct *parser, int status, int ch)
362 {
363 int retn = status;
364 struct ArgusInputCommand *ic;
365
366 if (status == RAGETTINGh) {
367 RaWindowStatus = 1;
368 wclear(RaCurrentWindow->window);
369
370 RaInputString = RANEWCOMMANDSTR;
371 bzero(RaCommandInputStr, MAXSTRLEN);
372 RaCommandIndex = 0;
373 RaCursorOffset = 0;
374 RaWindowCursorY = 0;
375 RaWindowCursorX = 0;
376
377 retn = RAGOTslash;
378 } else
379 if ((ic = ArgusInputHitTable[ch]) != NULL) {
380 retn = ic->process(RaCurrentWindow->window, status, ch);
381 }
382
383 return (retn);
384 }
385
386
387 int
ArgusProcessTerminator(WINDOW * win,int status,int ch)388 ArgusProcessTerminator(WINDOW *win, int status, int ch)
389 {
390 struct ArgusParserStruct *parser = ArgusParser;
391 int retn = status;
392 char *sbuf = NULL;
393
394 if ((sbuf = (char *)ArgusMalloc(MAXSTRLEN)) == NULL)
395 ArgusLog (LOG_ERR, "RaSQLProcessQueue: ArgusMalloc error %s", strerror(errno));
396
397 if ((ch == '\n') || (ch == '\r')) {
398 RaCursorOffset = 0;
399 RaCommandInputStr[RaCommandIndex] = '\0';
400 switch (retn) {
401 case RAGETTINGN: {
402 char *ptr = NULL;
403 int value = strtol(RaCommandInputStr, (char **)&ptr, 10);
404
405 if (ptr != RaCommandInputStr) {
406 int len = (RaScreenLines - (RaHeaderWinSize + RaStatusWinSize + RaDebugWinSize));
407 RaDisplayLines = ((value < len) ? value : len) + 1;
408 }
409
410 break;
411 }
412
413 case RAGETTINGS: {
414 if (!(ArgusAddHostList (ArgusParser, RaCommandInputStr, (ArgusParser->Cflag ? ARGUS_CISCO_DATA_SOURCE : ARGUS_DATA_SOURCE), 0))) {
415 ArgusLog (LOG_ALERT, "%s%s host not found", RaInputString, RaCommandInputStr);
416 } else {
417 ArgusDeleteHostList(ArgusParser);
418 ArgusAddHostList (ArgusParser, RaCommandInputStr, (ArgusParser->Cflag ? ARGUS_CISCO_DATA_SOURCE : ARGUS_DATA_SOURCE), 0);
419 ArgusParser->Sflag = 1;
420 ArgusParser->RaParseDone = 0;
421 }
422 break;
423 }
424
425 case RAGETTINGa: {
426 if (!(strncasecmp(RaCommandInputStr, "Totals", 6))) {
427 RaScreenResize = TRUE;
428 if (ArgusPrintTotals == 0) {
429 ArgusPrintTotals = 1;
430 RaHeaderWinSize++;
431 RaScreenMove = TRUE;
432 }
433 }
434 if (!(strncasecmp(RaCommandInputStr, "-Totals", 6))) {
435 RaScreenResize = TRUE;
436 if (ArgusPrintTotals > 0) {
437 ArgusPrintTotals = 0;
438 RaHeaderWinSize--;
439 RaScreenMove = FALSE;
440 getbegyx(RaCurrentWindow->window, RaScreenStartY, RaScreenStartX);
441 if (mvwin(RaCurrentWindow->window, RaScreenStartY - 1, RaScreenStartX) == ERR)
442 ArgusLog (LOG_ERR, "RaResizeScreen: mvwin %d, %d returned ERR\n", RaScreenStartY - 1, RaScreenStartX);
443 }
444 }
445 }
446 break;
447
448 case RAGETTINGd: {
449 struct ArgusInput *input;
450 char strbuf[MAXSTRLEN];
451
452 if ((input = (void *)ArgusParser->ArgusActiveHosts->start) != NULL) {
453 do {
454 sprintf (strbuf, "%s:%d", input->hostname, input->portnum);
455 if ((strstr (RaCommandInputStr, strbuf))) {
456 ArgusRemoveFromQueue (ArgusParser->ArgusActiveHosts, &input->qhdr, ARGUS_LOCK);
457 ArgusCloseInput(ArgusParser, input);
458 break;
459 }
460 input = (void *)input->qhdr.nxt;
461 } while (input != (void *)ArgusParser->ArgusActiveHosts->start);
462 }
463 }
464 break;
465
466 case RAGETTINGD: {
467 char *ptr = NULL;
468 int value = strtol(RaCommandInputStr, (char **)&ptr, 10);
469
470 if (ptr != RaCommandInputStr)
471 ArgusParser->debugflag = value;
472 break;
473 }
474
475 case RAGETTINGc: {
476 break;
477 }
478
479 case RAGETTINGe: {
480 char *ptr = NULL;
481
482 ptr = RaCommandInputStr;
483 while (isspace((int)*ptr)) ptr++;
484 if (ArgusParser->estr != NULL)
485 free(ArgusParser->estr);
486 ArgusParser->estr = strdup(RaCommandInputStr);
487 break;
488 }
489
490 case RAGETTINGf: {
491 struct nff_program lfilter;
492 char *ptr = NULL, *str = NULL;
493 int ind = ARGUS_REMOTE_FILTER;
494 int fretn, i;
495
496 bzero ((char *) &lfilter, sizeof (lfilter));
497 ptr = RaCommandInputStr;
498 while (isspace((int)*ptr)) ptr++;
499
500 if ((str = strstr (ptr, "local")) != NULL) {
501 ptr = strdup(&str[strlen("local ")]);
502 ind = ARGUS_LOCAL_FILTER;
503 } else
504 if ((str = strstr (ptr, "display")) != NULL) {
505 ptr = strdup(&str[strlen("display ")]);
506 ind = ARGUS_DISPLAY_FILTER;
507 } else
508 if ((str = strstr (ptr, "remote")) != NULL) {
509 ptr = strdup(&str[strlen("remote ")]);
510 ind = ARGUS_REMOTE_FILTER;
511 } else
512 if ((str = strstr (ptr, "none")) != NULL) {
513 ptr = NULL;
514 ind = RaFilterIndex;
515 } else
516 ptr = NULL;
517
518 if ((fretn = ArgusFilterCompile (&lfilter, ptr, 1)) < 0) {
519 sprintf (sbuf, "%s %s syntax error", RAGETTINGfSTR, RaCommandInputStr);
520 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
521 } else {
522 sprintf (sbuf, "%s %s filter accepted", RAGETTINGfSTR, RaCommandInputStr);
523 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
524 if ((str = ptr) != NULL)
525 while (isspace((int)*str)) str++;
526
527 switch (ind) {
528 case ARGUS_LOCAL_FILTER:
529 if (ArgusParser->ArgusFilterCode.bf_insns != NULL)
530 free (ArgusParser->ArgusFilterCode.bf_insns);
531
532 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusFilterCode, sizeof(lfilter));
533 if (ArgusParser->ArgusLocalFilter != NULL) {
534 free(ArgusParser->ArgusLocalFilter);
535 ArgusParser->ArgusLocalFilter = NULL;
536 }
537 if (str && (strlen(str) > 0))
538 ArgusParser->ArgusLocalFilter = ptr;
539 else
540 if (ptr != NULL) free(ptr);
541 break;
542
543 case ARGUS_DISPLAY_FILTER:
544 if (ArgusParser->ArgusDisplayCode.bf_insns != NULL)
545 free (ArgusParser->ArgusDisplayCode.bf_insns);
546
547 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusDisplayCode, sizeof(lfilter));
548 bcopy((char *)&lfilter, (char *)&ArgusSorter->filter, sizeof(lfilter));
549
550 if (ArgusParser->ArgusDisplayFilter != NULL) {
551 free(ArgusParser->ArgusDisplayFilter);
552 ArgusParser->ArgusDisplayFilter = NULL;
553 }
554 if (str && (strlen(str) > 0))
555 ArgusParser->ArgusDisplayFilter = ptr;
556 else
557 if (ptr != NULL) free(ptr);
558 break;
559
560 case ARGUS_REMOTE_FILTER:
561 if (ArgusParser->ArgusFilterCode.bf_insns != NULL)
562 free (ArgusParser->ArgusFilterCode.bf_insns);
563 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusFilterCode, sizeof(lfilter));
564 if (ArgusParser->ArgusRemoteFilter != NULL) {
565 free(ArgusParser->ArgusRemoteFilter);
566 ArgusParser->ArgusRemoteFilter = NULL;
567 }
568 if (str && (strlen(str) > 0))
569 ArgusParser->ArgusRemoteFilter = ptr;
570 else
571 if (ptr != NULL) free(ptr);
572 break;
573 }
574 }
575
576 #if defined(ARGUS_THREADS)
577 pthread_mutex_lock(&RaCursesProcess->queue->lock);
578 #endif
579 RaClientSortQueue(ArgusSorter, RaCursesProcess->queue, ARGUS_NOLOCK);
580
581 if (parser->ArgusAggregator != NULL) {
582 if (ArgusParser->ns) {
583 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
584 ArgusParser->ns = NULL;
585 }
586 for (i = 0; i < RaCursesProcess->queue->count; i++) {
587 struct ArgusRecordStruct *ns;
588 if ((ns = (struct ArgusRecordStruct *)RaCursesProcess->queue->array[i]) == NULL)
589 break;
590 if (ArgusParser->ns)
591 ArgusMergeRecords (parser->ArgusAggregator, ArgusParser->ns, ns);
592 else
593 ArgusParser->ns = ArgusCopyRecordStruct (ns);
594 }
595 #if defined(ARGUS_THREADS)
596 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
597 #endif
598 }
599
600 RaWindowStatus = 1;
601 break;
602 }
603
604 case RAGETTINGm: {
605 struct ArgusRecordStruct *ns = NULL;
606 char strbuf[MAXSTRLEN], *tok = NULL, *ptr;
607 struct ArgusModeStruct *mode = NULL, *modelist = NULL, *list;
608 struct ArgusAggregatorStruct *agg = parser->ArgusAggregator;
609 int i;
610
611 ArgusParser->RaMonMode = 0;
612
613 if ((agg->modeStr == NULL) || strcmp(agg->modeStr, RaCommandInputStr)) {
614 if (agg->modeStr != NULL)
615 free(agg->modeStr);
616 agg->modeStr = strdup(RaCommandInputStr);
617 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
618
619 if ((mode = ArgusParser->ArgusMaskList) != NULL)
620 ArgusDeleteMaskList(ArgusParser);
621
622 agg->mask = 0;
623 agg->saddrlen = 0;
624 agg->daddrlen = 0;
625
626 if ((ptr = strbuf) != NULL) {
627 while ((tok = strtok (ptr, " \t")) != NULL) {
628 if ((mode = (struct ArgusModeStruct *) ArgusCalloc (1, sizeof(struct ArgusModeStruct))) != NULL) {
629 if ((list = modelist) != NULL) {
630 while (list->nxt)
631 list = list->nxt;
632 list->nxt = mode;
633 } else
634 modelist = mode;
635 mode->mode = strdup(tok);
636 }
637 ptr = NULL;
638 }
639 } else {
640 if ((modelist = ArgusParser->ArgusMaskList) == NULL)
641 agg->mask = ( ARGUS_MASK_SRCID_INDEX | ARGUS_MASK_PROTO_INDEX |
642 ARGUS_MASK_SADDR_INDEX | ARGUS_MASK_SPORT_INDEX |
643 ARGUS_MASK_DADDR_INDEX | ARGUS_MASK_DPORT_INDEX );
644 }
645
646 ArgusInitAggregatorStructs(agg);
647
648 if ((mode = modelist) != NULL) {
649 while (mode) {
650 char *ptr = NULL, **endptr = NULL;
651 int value = 0;
652
653 if ((ptr = strchr(mode->mode, '/')) != NULL) {
654 ptr++;
655 if ((value = strtol(ptr, endptr, 10)) == 0)
656 if (*endptr == ptr)
657 usage();
658 }
659 if (!(strncasecmp (mode->mode, "none", 4))) {
660 agg->mask = 0;
661 } else
662 if (!(strncasecmp (mode->mode, "macmatrix", 9))) {
663 agg->ArgusMatrixMode++;
664 agg->mask |= (0x01LL << ARGUS_MASK_SMAC);
665 agg->mask |= (0x01LL << ARGUS_MASK_DMAC);
666 if (value > 0) {
667 agg->saddrlen = value;
668 agg->daddrlen = value;
669 }
670 } else
671 if (!(strncasecmp (mode->mode, "mac", 3))) {
672 ArgusParser->RaMonMode++;
673 if (agg->correct != NULL) {
674 free(agg->correct);
675 agg->correct = NULL;
676 }
677 agg->mask |= (0x01LL << ARGUS_MASK_SMAC);
678 if (value > 0) {
679 agg->saddrlen = value;
680 agg->daddrlen = value;
681 }
682 } else
683 if (!(strncasecmp (mode->mode, "addr", 4))) {
684 ArgusParser->RaMonMode++;
685 if (agg->correct != NULL) {
686 free(agg->correct);
687 agg->correct = NULL;
688 }
689 agg->mask |= (0x01LL << ARGUS_MASK_SADDR);
690 if (value > 0) {
691 agg->saddrlen = value;
692 agg->daddrlen = value;
693 }
694 } else
695 if (!(strncasecmp (mode->mode, "matrix", 6))) {
696 agg->ArgusMatrixMode++;
697 agg->mask |= (0x01LL << ARGUS_MASK_SADDR);
698 agg->mask |= (0x01LL << ARGUS_MASK_DADDR);
699 if (value > 0) {
700 agg->saddrlen = value;
701 agg->daddrlen = value;
702 }
703 } else {
704 struct ArgusMaskStruct *ArgusMaskDefs = ArgusIpV4MaskDefs;
705
706 for (i = 0; i < ARGUS_MAX_MASK_LIST; i++) {
707 if (!(strncasecmp (mode->mode, ArgusMaskDefs[i].name, ArgusMaskDefs[i].slen))) {
708 agg->mask |= (0x01LL << i);
709 switch (i) {
710 case ARGUS_MASK_SADDR:
711 if (value > 0) {
712 agg->saddrlen = value;
713 if (value <= 32)
714 agg->smask.addr_un.ipv4 = (0xFFFFFFFF << (32 - value));
715 }
716 break;
717
718 case ARGUS_MASK_DADDR:
719 if (value > 0) {
720 agg->daddrlen = value;
721 if (value <= 32)
722 agg->dmask.addr_un.ipv4 = (0xFFFFFFFF << (32 - value));
723 }
724 break;
725
726 case ARGUS_MASK_SMPLS:
727 case ARGUS_MASK_DMPLS: {
728 int x, RaNewIndex = 0;
729 char *ptr;
730
731 if ((ptr = strchr(mode->mode, '[')) != NULL) {
732 char *cptr = NULL;
733 int sind = -1, dind = -1;
734 *ptr++ = '\0';
735 while (*ptr != ']') {
736 if (isdigit((int)*ptr)) {
737 dind = strtol(ptr, (char **)&cptr, 10);
738 if (cptr == ptr)
739 usage ();
740
741 if (sind < 0)
742 sind = dind;
743
744 for (x = sind; x <= dind; x++)
745 RaNewIndex |= 0x01 << x;
746
747 ptr = cptr;
748 if (*ptr != ']')
749 ptr++;
750 if (*cptr != '-')
751 sind = -1;
752 } else
753 usage ();
754 }
755 ArgusIpV4MaskDefs[i].index = RaNewIndex;
756 ArgusIpV6MaskDefs[i].index = RaNewIndex;
757 ArgusEtherMaskDefs[i].index = RaNewIndex;
758 }
759 break;
760 }
761 }
762 break;
763 }
764 }
765 }
766 mode = mode->nxt;
767 }
768 }
769
770 ArgusParser->ArgusMaskList = modelist;
771
772 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(RaCursesProcess->queue, ARGUS_LOCK)) != NULL) {
773 if (ArgusSearchHitRecord == ns)
774 ArgusResetSearch();
775 ArgusDeleteRecordStruct (ArgusParser, ns);
776 }
777
778 ArgusEmptyHashTable(RaCursesProcess->htable);
779 if (ArgusParser->ns) {
780 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
781 ArgusParser->ns = NULL;
782 }
783
784 ArgusParser->RaClientUpdate.tv_sec = 0;
785
786 werase(RaCurrentWindow->window);
787 ArgusTouchScreen();
788 }
789
790 break;
791 }
792
793 case RAGETTINGM: {
794 char strbuf[MAXSTRLEN], *str = strbuf, *tok = NULL;
795 struct ArgusModeStruct *mode = NULL;
796 int mretn = 0;
797 char *tzptr;
798
799 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
800
801 if ((tzptr = strstr(strbuf, "TZ=")) != NULL) {
802 if (ArgusParser->RaTimeZone)
803 free (ArgusParser->RaTimeZone);
804 ArgusParser->RaTimeZone = strdup(tzptr);
805 tzptr = getenv("TZ");
806 #if defined(HAVE_SETENV) && HAVE_SETENV
807 if ((mretn = setenv("TZ", (ArgusParser->RaTimeZone + 3), 1)) < 0) {
808 sprintf (sbuf, "setenv(TZ, %s, 1) error %s", ArgusParser->RaTimeZone + 3, strerror(errno));
809 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
810 }
811 #else
812 if ((mretn = putenv(ArgusParser->RaTimeZone)) < 0) {
813 sprintf (sbuf, "setenv(TZ, %s, 1) error %s", ArgusParser->RaTimeZone + 3, strerror(errno));
814 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
815 }
816 #endif
817 if (mretn == 0) {
818 tzset();
819 sprintf (sbuf, "Timezone changed from %s to %s", tzptr, getenv("TZ"));
820 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
821 }
822
823 ArgusTouchScreen();
824 break;
825 }
826
827 if ((mode = ArgusParser->ArgusModeList) != NULL) {
828 ArgusDeleteModeList(ArgusParser);
829 ArgusParser->RaCumulativeMerge = 1;
830 }
831
832 if (strlen(strbuf) > 0) {
833 while ((tok = strtok(str, " \t\n")) != NULL) {
834 if (!(strncasecmp (tok, "none", 4)))
835 ArgusDeleteModeList(ArgusParser);
836 else if (!(strncasecmp (tok, "default", 7))) {
837 ArgusDeleteModeList(ArgusParser);
838 } else
839 ArgusAddModeList (ArgusParser, tok);
840 str = NULL;
841 }
842 }
843
844 if ((mode = ArgusParser->ArgusModeList) != NULL) {
845 struct ArgusAdjustStruct *nadp = NULL;
846 struct RaBinProcessStruct *RaBinProcess = parser->RaBinProcess;
847 int i, ind;
848
849 while (mode) {
850 for (i = 0, ind = -1; i < ARGUSSPLITMODENUM; i++) {
851 if (!(strncasecmp (mode->mode, RaSplitModes[i], strlen(RaSplitModes[i])))) {
852 ind = i;
853 break;
854 }
855 }
856
857 if (ind >= 0) {
858 char *mptr = NULL;
859 int size = -1;
860 nadp = &RaBinProcess->nadp;
861
862 nadp = &RaBinProcess->nadp;
863
864 switch (ind) {
865 case ARGUSSPLITRATE: { /* "%d:%d[yMwdhms]" */
866 struct ArgusModeStruct *tmode = NULL;
867 nadp->mode = ind;
868 if ((tmode = mode->nxt) != NULL) {
869 mptr = tmode->mode;
870 if (isdigit((int)*tmode->mode)) {
871 char *ptr = NULL;
872 nadp->len = strtol(tmode->mode, (char **)&ptr, 10);
873 if (*ptr++ != ':')
874 usage();
875 tmode->mode = ptr;
876 }
877 }
878 }
879
880 case ARGUSSPLITTIME: /* "%d[yMwdhms] */
881 nadp->mode = ind;
882 if ((mode = mode->nxt) != NULL) {
883 if (isdigit((int)*mode->mode)) {
884 char *ptr = NULL;
885 nadp->value = strtol(mode->mode, (char **)&ptr, 10);
886 if (ptr == mode->mode)
887 usage();
888 else {
889 switch (*ptr) {
890 case 'y':
891 nadp->qual = ARGUSSPLITYEAR;
892 size = nadp->value * 31556926;
893 break;
894 case 'M':
895 nadp->qual = ARGUSSPLITMONTH;
896 size = nadp->value * 2629744;
897 break;
898 case 'w':
899 nadp->qual = ARGUSSPLITWEEK;
900 size = nadp->value * 604800;
901 break;
902 case 'd':
903 nadp->qual = ARGUSSPLITDAY;
904 size = nadp->value * 86400;
905 break;
906 case 'h':
907 nadp->qual = ARGUSSPLITHOUR;
908 size = nadp->value * 3600;
909 break;
910 case 'm':
911 nadp->qual = ARGUSSPLITMINUTE;
912 size = nadp->value * 60;
913 break;
914 default:
915 nadp->qual = ARGUSSPLITSECOND;
916 size = nadp->value;
917 break;
918 }
919 }
920 }
921 if (mptr != NULL)
922 mode->mode = mptr;
923 }
924
925 nadp->modify = 1;
926
927 if (ind == ARGUSSPLITRATE) {
928 /* need to set the flow idle timeout value to be equal to or
929 just a bit bigger than (nadp->len * size) */
930
931 ArgusParser->timeout.tv_sec = (nadp->len * size);
932 ArgusParser->timeout.tv_usec = 0;
933 }
934
935 ArgusSorter->ArgusSortAlgorithms[0] = ArgusSortStartTime;
936 ArgusSorter->ArgusSortAlgorithms[1] = NULL;
937 break;
938
939 case ARGUSSPLITSIZE:
940 case ARGUSSPLITCOUNT:
941 nadp->mode = ind;
942 nadp->count = 1;
943
944 if ((mode = mode->nxt) != NULL) {
945 if (isdigit((int)*mode->mode)) {
946 char *ptr = NULL;
947 nadp->value = strtol(mode->mode, (char **)&ptr, 10);
948 if (ptr == mode->mode)
949 usage();
950 else {
951 switch (*ptr) {
952 case 'B':
953 case 'b': nadp->value *= 1000000000; break;
954
955 case 'M':
956 case 'm': nadp->value *= 1000000; break;
957
958 case 'K':
959 case 'k': nadp->value *= 1000; break;
960 }
961 }
962 }
963 }
964 ArgusSorter->ArgusSortAlgorithms[0] = NULL;
965 break;
966
967 case ARGUSSPLITNOMODIFY:
968 nadp->modify = 0;
969 break;
970
971 case ARGUSSPLITHARD:
972 nadp->hard++;
973 break;
974
975 case ARGUSSPLITZERO:
976 nadp->zero++;
977 break;
978 }
979
980 } else {
981 if (!(strncasecmp (mode->mode, "nomerge", 7))) {
982 ArgusParser->RaCumulativeMerge = 0;
983 } else
984 if (!(strncasecmp (mode->mode, "merge", 5))) {
985 ArgusParser->RaCumulativeMerge = 1;
986 }
987 }
988
989 mode = mode->nxt;
990 }
991 }
992
993 break;
994 }
995
996 case RAGETTINGn: {
997 char *name = NULL;;
998 if (strstr(RaCommandInputStr, "all")) ArgusParser->nflag = 0; else
999 if (strstr(RaCommandInputStr, "port")) ArgusParser->nflag = 1; else
1000 if (strstr(RaCommandInputStr, "proto")) ArgusParser->nflag = 2; else
1001 if (strstr(RaCommandInputStr, "none")) ArgusParser->nflag = 3;
1002
1003 switch (ArgusParser->nflag) {
1004 case 0: name = "all"; break;
1005 case 1: name = "port"; break;
1006 case 2: name = "proto"; break;
1007 case 3: name = "none"; break;
1008 default: name = "port"; ArgusParser->nflag = 1; break;
1009 }
1010
1011 sprintf (sbuf, "%s changed to %s ", RAGETTINGnSTR, name);
1012 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
1013 ArgusProcessNewPage(RaCurrentWindow->window, 0, 0);
1014 break;
1015 }
1016
1017 case RAGETTINGp: {
1018 int value = 0;
1019 char *endptr = NULL;
1020
1021 value = strtod(RaCommandInputStr, &endptr);
1022
1023 if (RaCommandInputStr != endptr) {
1024 ArgusParser->pflag = value;
1025 } else {
1026 sprintf (sbuf, "%s %s syntax error", RAGETTINGuSTR, RaCommandInputStr);
1027 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1028 }
1029 break;
1030 }
1031
1032 case RAGETTINGR: {
1033 char strbuf[MAXSTRLEN], *str = strbuf, *ptr = NULL;
1034 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
1035
1036 if (strlen(strbuf) > 0) {
1037 ArgusDeleteFileList(ArgusParser);
1038 while ((ptr = strtok(str, " ")) != NULL) {
1039 RaProcessRecursiveFiles (ptr);
1040 str = NULL;
1041 }
1042 }
1043 break;
1044 }
1045
1046 case RAGETTINGr: {
1047 char strbuf[MAXSTRLEN], *str = strbuf, *ptr = NULL;
1048 glob_t globbuf;
1049
1050 bzero (strbuf, MAXSTRLEN);
1051 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
1052
1053 if (strlen(strbuf) > 0) {
1054 struct ArgusRecordStruct *ns = NULL;
1055
1056 ArgusDeleteFileList(ArgusParser);
1057 while ((ptr = strtok(str, " ")) != NULL) {
1058 glob (ptr, 0, NULL, &globbuf);
1059 if (globbuf.gl_pathc > 0) {
1060 int i;
1061 for (i = 0; i < globbuf.gl_pathc; i++)
1062 ArgusAddFileList (ArgusParser, globbuf.gl_pathv[i], ARGUS_DATA_SOURCE, -1, -1);
1063 } else {
1064 sprintf (sbuf, "%s no files found for %s", RAGETTINGrSTR, ptr);
1065 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1066 }
1067 str = NULL;
1068 }
1069 ArgusParser->RaTasksToDo = 1;
1070 ArgusParser->Sflag = 0;
1071 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(RaCursesProcess->queue, ARGUS_LOCK)) != NULL) {
1072 if (ArgusSearchHitRecord == ns) {
1073 ArgusResetSearch();
1074 }
1075 ArgusDeleteRecordStruct (ArgusParser, ns);
1076 }
1077 ArgusEmptyHashTable(RaCursesProcess->htable);
1078 if (ArgusParser->ns) {
1079 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
1080 ArgusParser->ns = NULL;
1081 }
1082
1083 ArgusParser->RaClientUpdate.tv_sec = 0;
1084 ArgusParser->status &= ~ARGUS_FILE_LIST_PROCESSED;
1085 ArgusParser->ArgusLastTime.tv_sec = 0;
1086 ArgusParser->ArgusLastTime.tv_usec = 0;
1087 }
1088 break;
1089 }
1090
1091 case RAGETTINGs: {
1092 char strbuf[MAXSTRLEN], *ptr = strbuf, *tok;
1093 int (*srtalg[ARGUS_MAX_SORT_ALG])(struct ArgusRecordStruct *, struct ArgusRecordStruct *);
1094 int i, x, ind = 0;
1095 strncpy (strbuf, RaCommandInputStr, MAXSTRLEN);
1096 bzero(srtalg, sizeof(srtalg));
1097 while ((tok = strtok(ptr, " ")) != NULL) {
1098 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++) {
1099 if (!strncmp (ArgusSortKeyWords[x], tok, strlen(ArgusSortKeyWords[x]))) {
1100 srtalg[ind++] = ArgusSortAlgorithmTable[x];
1101 break;
1102 }
1103 }
1104 if (x == ARGUS_MAX_SORT_ALG) {
1105 bzero(srtalg, sizeof(srtalg));
1106 ArgusLog (LOG_ALERT, "sort keyword %s not valid", tok);
1107 break;
1108 }
1109 ptr = NULL;
1110 }
1111
1112 if (srtalg[0] != NULL) {
1113 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++)
1114 ArgusSorter->ArgusSortAlgorithms[x] = srtalg[x];
1115 }
1116
1117 #if defined(ARGUS_THREADS)
1118 pthread_mutex_lock(&RaCursesProcess->queue->lock);
1119 #endif
1120 RaClientSortQueue(ArgusSorter, RaCursesProcess->queue, ARGUS_NOLOCK);
1121 if (ArgusParser->ns) {
1122 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
1123 ArgusParser->ns = NULL;
1124 }
1125 for (i = 0; i < RaCursesProcess->queue->count; i++) {
1126 struct ArgusRecordStruct *ns;
1127 if ((ns = (struct ArgusRecordStruct *)RaCursesProcess->queue->array[i]) == NULL)
1128 break;
1129 if (ArgusParser->ns)
1130 ArgusMergeRecords (parser->ArgusAggregator, ArgusParser->ns, ns);
1131 else
1132 ArgusParser->ns = ArgusCopyRecordStruct (ns);
1133 }
1134 #if defined(ARGUS_THREADS)
1135 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
1136 #endif
1137 ArgusTouchScreen();
1138 break;
1139 }
1140
1141 case RAGETTINGT: {
1142 double sec, usec, value;
1143 char *ptr = NULL;
1144
1145 value = strtod(RaCommandInputStr, (char **)&ptr);
1146 if (ptr != RaCommandInputStr) {
1147 usec = modf(value, &sec);
1148 ArgusParser->timeout.tv_sec = sec;
1149 ArgusParser->timeout.tv_usec = usec;
1150 }
1151 break;
1152 }
1153
1154 case RAGETTINGt: {
1155 if (ArgusParser->timearg) {
1156 free (ArgusParser->timearg);
1157 ArgusParser->timearg = NULL;
1158 }
1159
1160 if (strlen(RaCommandInputStr))
1161 ArgusParser->timearg = strdup(RaCommandInputStr);
1162
1163 ArgusCheckTimeFormat (&ArgusParser->RaTmStruct, ArgusParser->timearg);
1164 break;
1165 }
1166
1167 case RAGETTINGu: {
1168 double value = 0.0, ivalue, fvalue;
1169 char *endptr = NULL;
1170 #if defined(ARGUS_READLINE)
1171 int keytimeout;
1172 #endif
1173
1174 value = strtod(RaCommandInputStr, &endptr);
1175
1176 if (RaCommandInputStr != endptr) {
1177 fvalue = modf(value, &ivalue);
1178
1179 RaCursesUpdateInterval.tv_sec = (int) ivalue;
1180 RaCursesUpdateInterval.tv_usec = (int) (fvalue * 1000000.0);
1181
1182 #if defined(ARGUS_READLINE)
1183 keytimeout = (RaCursesUpdateInterval.tv_sec * 1000000) + RaCursesUpdateInterval.tv_usec;
1184 keytimeout = (keytimeout == 1000000) ? keytimeout - 1 : keytimeout;
1185 #if defined(HAVE_DECL_RL_SET_KEYBOARD_INPUT_TIMEOUT) && HAVE_DECL_RL_SET_KEYBOARD_INPUT_TIMEOUT
1186 rl_set_keyboard_input_timeout (keytimeout);
1187 #endif
1188 #endif
1189 sprintf (sbuf, "%s %s interval accepted", RAGETTINGuSTR, RaCommandInputStr);
1190 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
1191 RaCursesUpdateTime = ArgusParser->ArgusRealTime;
1192
1193 } else {
1194 sprintf (sbuf, "%s %s syntax error", RAGETTINGuSTR, RaCommandInputStr);
1195 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1196 }
1197
1198 break;
1199 }
1200
1201 case RAGETTINGU: {
1202 double value = 0.0;
1203 char *endptr = NULL;
1204
1205 value = strtod(RaCommandInputStr, &endptr);
1206
1207 if (RaCommandInputStr != endptr) {
1208 RaUpdateRate = value;
1209 sprintf (sbuf, "%s %s accepted", RAGETTINGUSTR, RaCommandInputStr);
1210 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
1211
1212 } else {
1213 sprintf (sbuf, "%s %s syntax error", RAGETTINGUSTR, RaCommandInputStr);
1214 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1215 }
1216
1217 break;
1218 }
1219
1220
1221 case RAGETTINGw: {
1222 struct ArgusListStruct *wlist = ArgusParser->ArgusWfileList;
1223 struct ArgusWfileStruct *wfile = NULL;
1224 struct ArgusRecord *argusrec = NULL;
1225 struct ArgusRecordStruct *ns;
1226 static char buf[0x10000];
1227 int i;
1228
1229 if (strlen(RaCommandInputStr)) {
1230 if (RaCursesProcess->queue->count > 0) {
1231 ArgusParser->ArgusWfileList = NULL;
1232 setArgusWfile (ArgusParser, RaCommandInputStr, NULL);
1233 wfile = (struct ArgusWfileStruct *) ArgusParser->ArgusWfileList->start;
1234
1235 for (i = 0; i < RaCursesProcess->queue->count; i++) {
1236 int pass = 1;
1237
1238 if ((ns = (struct ArgusRecordStruct *) RaCursesProcess->queue->array[i]) == NULL)
1239 break;
1240
1241 if (wfile->filterstr) {
1242 struct nff_insn *wfcode = wfile->filter.bf_insns;
1243 pass = ArgusFilterRecord (wfcode, ns);
1244 }
1245
1246 if (pass != 0) {
1247 if ((argusrec = ArgusGenerateRecord (ns, 0L, buf)) != NULL) {
1248 #ifdef _LITTLE_ENDIAN
1249 ArgusHtoN(argusrec);
1250 #endif
1251 ArgusWriteNewLogfile (ArgusParser, ns->input, wfile, argusrec);
1252
1253 }
1254 }
1255 }
1256
1257 fflush(wfile->fd);
1258 fclose(wfile->fd);
1259 clearArgusWfile(ArgusParser);
1260 ArgusParser->ArgusWfileList = wlist;
1261 }
1262 }
1263
1264 break;
1265 }
1266
1267 case RAGETTINGF: {
1268 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
1269 char strbuf[MAXSTRLEN], *ptr = strbuf, *tok;
1270 int x;
1271
1272 strncpy (strbuf, RaCommandInputStr, MAXSTRLEN);
1273 bzero ((char *)ArgusParser->RaPrintOptionStrings, sizeof(ArgusParser->RaPrintOptionStrings));
1274 ArgusParser->RaPrintOptionIndex = 0;
1275 while ((tok = strtok(ptr, " ")) != NULL) {
1276 if (ArgusParser->RaPrintOptionIndex < ARGUS_MAX_S_OPTIONS)
1277 ArgusParser->RaPrintOptionStrings[ArgusParser->RaPrintOptionIndex++] = tok;
1278 ptr = NULL;
1279 }
1280
1281 if (ArgusParser->RaPrintOptionIndex > 0) {
1282 ArgusProcessSOptions(ArgusParser);
1283 for (x = 0; x < ArgusParser->RaPrintOptionIndex; x++)
1284 if (ArgusParser->RaPrintOptionStrings[x] != NULL)
1285 ArgusParser->RaPrintOptionStrings[x] = NULL;
1286 ArgusParser->RaPrintOptionIndex = 0;
1287 }
1288
1289 for (x = 0, ArgusAlwaysUpdate = 0; x < MAX_PRINT_ALG_TYPES; x++)
1290 if (parser->RaPrintAlgorithmList[x] != NULL)
1291 if (parser->RaPrintAlgorithmList[x]->print == ArgusPrintIdleTime)
1292 ArgusAlwaysUpdate++;
1293
1294 if (queue == RaCursesProcess->queue) {
1295 int i;
1296 if (ArgusParser->ns) {
1297 ArgusParser->ns->status |= ARGUS_RECORD_MODIFIED;
1298 }
1299 for (i = 0; i < queue->count; i++) {
1300 struct ArgusRecordStruct *ns;
1301 if ((ns = (struct ArgusRecordStruct *)queue->array[i]) == NULL)
1302 break;
1303 ns->status |= ARGUS_RECORD_MODIFIED;
1304 }
1305 }
1306 ArgusTouchScreen();
1307 break;
1308 }
1309
1310 case RAGETTINGcolon: {
1311 char *endptr = NULL;
1312 int linenum, startline;
1313
1314 linenum = (int)strtol(RaCommandInputStr, &endptr, 10);
1315 if (RaCommandInputStr == endptr) {
1316 switch (*RaCommandInputStr) {
1317 case 'q': {
1318 bzero (RaCommandInputStr, MAXSTRLEN);
1319 ArgusTouchScreen();
1320 RaParseComplete(SIGINT);
1321 break;
1322 }
1323 }
1324 } else {
1325 if ((linenum >= RaWindowStartLine) && (linenum <= (RaWindowStartLine + RaDisplayLines)))
1326 RaWindowCursorY = linenum - RaWindowStartLine;
1327 else {
1328 startline = ((linenum - 1)/ RaDisplayLines) * RaDisplayLines;
1329 startline = (RaCursesProcess->queue->count > startline) ? startline : RaCursesProcess->queue->count - RaDisplayLines;
1330 startline = (startline > 0) ? startline : 0;
1331 RaWindowStartLine = startline;
1332 if ((RaWindowCursorY = linenum % RaDisplayLines) == 0)
1333 RaWindowCursorY = RaDisplayLines;
1334 }
1335 retn = RAGOTcolon;
1336 RaCursesSetWindowFocus(ArgusParser, RaCurrentWindow->window);
1337 ArgusTouchScreen();
1338 }
1339 break;
1340 }
1341
1342 case RAGETTINGslash: {
1343 int linenum = RaWindowCursorY;
1344 int cursx = RaWindowCursorX, cursy = RaWindowCursorY + RaWindowStartLine;
1345
1346 if ((linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, RaCommandInputStr, ARGUS_LOCK)) < 0) {
1347 if (ArgusSearchDirection == ARGUS_FORWARD) {
1348 sprintf (sbuf, "search hit BOTTOM, continuing at TOP");
1349 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1350 cursx = 0; cursy = 0;
1351 } else {
1352 sprintf (sbuf, "search hit TOP, continuing at BOTTOM");
1353 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1354 cursx = RaScreenColumns; cursy = RaCursesProcess->queue->count;
1355 }
1356 linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, RaCommandInputStr, ARGUS_LOCK);
1357 }
1358
1359 if (linenum >= 0) {
1360 int startline = ((cursy - 1)/ RaDisplayLines) * RaDisplayLines;
1361
1362 startline = (RaCursesProcess->queue->count > startline) ? startline : RaCursesProcess->queue->count - RaDisplayLines;
1363 startline = (startline > 0) ? startline : 0;
1364 retn = RAGOTslash;
1365 RaWindowStartLine = startline;
1366 if ((RaWindowCursorY = cursy % RaDisplayLines) == 0)
1367 RaWindowCursorY = RaDisplayLines;
1368 RaWindowCursorX = cursx;
1369
1370
1371 } else {
1372 sprintf (sbuf, "Pattern not found: %s", RaCommandInputStr);
1373 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1374 retn = RAGOTslash;
1375 RaInputString = RANEWCOMMANDSTR;
1376 bzero(RaCommandInputStr, MAXSTRLEN);
1377 RaCommandIndex = 0;
1378 RaCursorOffset = 0;
1379 RaWindowCursorY = 0;
1380 RaWindowCursorX = 0;
1381 }
1382
1383 RaCursesSetWindowFocus(ArgusParser, RaCurrentWindow->window);
1384 retn = RAGOTslash;
1385 RaInputString = "/";
1386 ArgusTouchScreen();
1387 break;
1388 }
1389 }
1390
1391 if ((retn != RAGOTslash) && (retn != RAGOTcolon)) {
1392 retn = RAGOTslash;
1393 RaInputString = RANEWCOMMANDSTR;
1394 RaCommandInputStr[0] = '\0';
1395 }
1396 }
1397 if (sbuf != NULL) ArgusFree(sbuf);
1398
1399 #ifdef ARGUSDEBUG
1400 ArgusDebug (1, "ArgusProcessTerminator(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch, retn);
1401 #endif
1402 return (retn);
1403 }
1404
1405 int
ArgusProcessNewPage(WINDOW * win,int status,int ch)1406 ArgusProcessNewPage(WINDOW *win, int status, int ch)
1407 {
1408 int retn = status;
1409
1410 bzero(&RaCursesUpdateTime, sizeof(RaCursesUpdateTime));
1411 wclear(RaCurrentWindow->window);
1412 RaWindowStatus = 1;
1413
1414 ArgusUpdateScreen();
1415 RaRefreshDisplay();
1416
1417 #ifdef ARGUSDEBUG
1418 ArgusDebug (1, "ArgusProcessNewPage(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1419 #endif
1420 return (retn);
1421 }
1422
1423 int
ArgusProcessDeviceControl(WINDOW * win,int status,int ch)1424 ArgusProcessDeviceControl(WINDOW *win, int status, int ch)
1425 {
1426 int retn = status;
1427
1428 switch (ch) {
1429 case 0x11:
1430 case 0x13:
1431 case 0x14: {
1432 break;
1433 }
1434 case 0x12: {
1435 int startline = RaWindowCursorY + RaWindowStartLine;
1436 struct ArgusRecordStruct *ns;
1437
1438 if ((ns = (struct ArgusRecordStruct *) RaCursesProcess->queue->array[startline - 1]) != NULL) {
1439
1440 ArgusRemoveFromQueue(RaCursesProcess->queue, &ns->qhdr, ARGUS_LOCK);
1441 ArgusReverseRecord(ns);
1442
1443 if (ns->htblhdr != NULL)
1444 ArgusRemoveHashEntry(&ns->htblhdr);
1445
1446 RaProcessThisRecord (ArgusParser, ns);
1447
1448 RaWindowCursorY++;
1449 if ((RaCursesProcess->queue->count - RaWindowStartLine) < RaDisplayLines) {
1450 int maxwincount = RaCursesProcess->queue->count - RaWindowStartLine;
1451 if (RaWindowCursorY > maxwincount) {
1452 RaWindowCursorY = maxwincount;
1453 beep();
1454 }
1455
1456 } else {
1457 if (RaWindowCursorY > RaDisplayLines) {
1458 if ((RaCursesProcess->queue->count - RaWindowStartLine) > RaDisplayLines) {
1459 RaWindowStartLine++;
1460 wscrl(RaCurrentWindow->window, 1);
1461 ArgusTouchScreen();
1462 } else
1463 beep();
1464
1465 RaWindowCursorY = RaDisplayLines;
1466 }
1467 }
1468 ArgusTouchScreen();
1469 }
1470 break;
1471 }
1472 }
1473
1474 #ifdef ARGUSDEBUG
1475 ArgusDebug (1, "ArgusProcessDeviceControl(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1476 #endif
1477 return (retn);
1478 }
1479
1480 int
ArgusProcessEscape(WINDOW * win,int status,int ch)1481 ArgusProcessEscape(WINDOW *win, int status, int ch)
1482 {
1483 int retn = status;
1484
1485 #if defined(ARGUS_READLINE)
1486 struct timeval tvbuf, *tvp = &tvbuf;
1487 int eindex = 0;
1488 int escbuf[16];
1489 fd_set in;
1490
1491 bzero(escbuf, sizeof(escbuf));
1492 tvp->tv_sec = 0; tvp->tv_usec = 100000;
1493 FD_ZERO(&in); FD_SET(0, &in);
1494 while ((select(1, &in, 0, 0, tvp) > 0) && (eindex < 2)) {
1495 if ((ch = wgetch(RaStatusWindow)) != ERR) {
1496 escbuf[eindex++] = ch;
1497 }
1498 FD_ZERO(&in); FD_SET(0, &in);
1499 }
1500
1501 if (eindex == 2) {
1502 int offset;
1503 switch (escbuf[0]) {
1504 case '[': // process ESC
1505 switch (escbuf[1]) {
1506 case 'A': // cursor up
1507 RaWindowCursorY--;
1508 if (RaWindowCursorY < 1) {
1509 RaWindowCursorY = 1;
1510 if (RaWindowStartLine > 0) {
1511 RaWindowStartLine--;
1512 wscrl(RaCurrentWindow->window, -1);
1513 ArgusTouchScreen();
1514 } else
1515 beep();
1516 }
1517 break;
1518 case 'B': // cursor down
1519 RaWindowCursorY++;
1520 if ((RaCursesProcess->queue->count - RaWindowStartLine) < RaDisplayLines) {
1521 int maxwincount = RaCursesProcess->queue->count - RaWindowStartLine;
1522 if (RaWindowCursorY > maxwincount) {
1523 RaWindowCursorY = maxwincount;
1524 beep();
1525 }
1526
1527 } else {
1528 if (RaWindowCursorY > RaDisplayLines) {
1529 if ((RaCursesProcess->queue->count - RaWindowStartLine) > RaDisplayLines) {
1530 RaWindowStartLine++;
1531 wscrl(RaCurrentWindow->window, 1);
1532 ArgusTouchScreen();
1533 } else
1534 beep();
1535
1536 RaWindowCursorY = RaDisplayLines;
1537 }
1538 }
1539 break;
1540 case 'C': { // cursor forward
1541 int startline = RaWindowCursorY + RaWindowStartLine;
1542 struct ArgusRecordStruct *ns;
1543 int len;
1544
1545 if ((ns = (struct ArgusRecordStruct *) RaCursesProcess->queue->array[startline - 1]) != NULL) {
1546 char buf[MAXSTRLEN];
1547
1548 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != startline)) {
1549 if (ns->disp.str != NULL)
1550 free(ns->disp.str);
1551
1552 buf[0] = '\0';
1553 ns->rank = startline;
1554 ArgusPrintRecord(ArgusParser, buf, ns, MAXSTRLEN);
1555 ns->disp.str = strdup(buf);
1556 ns->status &= ~ARGUS_RECORD_MODIFIED;
1557 }
1558
1559 len = strlen(ns->disp.str);
1560
1561 bcopy(ns->disp.str, buf, len + 1);
1562 RaWindowCursorX++;
1563 if (RaWindowCursorX >= len) {
1564 RaWindowCursorX = len - 1;
1565 beep();
1566 }
1567 }
1568 ArgusTouchScreen();
1569 break;
1570 }
1571
1572 case 'D': // cursor backward
1573 RaWindowCursorX--;
1574 if (RaWindowCursorX < 0) {
1575 RaWindowCursorX = 0;
1576 beep();
1577 }
1578 ArgusTouchScreen();
1579 break;
1580 }
1581 break;
1582 default:
1583 break;
1584 }
1585 offset = (RaWindowCursorY % (RaDisplayLines + 1));
1586 if (offset > (RaSortItems - RaWindowStartLine)) {
1587 RaWindowCursorY = (RaSortItems - RaWindowStartLine);
1588 offset = (RaSortItems - RaWindowStartLine);
1589 }
1590 offset += RaHeaderWinSize;
1591 wmove (RaCurrentWindow->window, offset, RaWindowCursorX);
1592 }
1593 #endif
1594
1595 #ifdef ARGUSDEBUG
1596 ArgusDebug (1, "ArgusProcessEscape(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1597 #endif
1598
1599 return (retn);
1600 }
1601
1602 int
ArgusProcessEndofTransmission(WINDOW * win,int status,int ch)1603 ArgusProcessEndofTransmission (WINDOW *win, int status, int ch)
1604 {
1605 int retn = status;
1606
1607 bzero (RaCommandInputStr, MAXSTRLEN);
1608 RaCommandIndex = 0;
1609 RaCursorOffset = 0;
1610
1611 #ifdef ARGUSDEBUG
1612 ArgusDebug (1, "ArgusProcessEndOfTransmission(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1613 #endif
1614
1615 return (retn);
1616 }
1617
1618 int
ArgusProcessKeyUp(WINDOW * win,int status,int ch)1619 ArgusProcessKeyUp (WINDOW *win, int status, int ch)
1620 {
1621 int retn = status;
1622 int done = 0, start = RaFilterIndex;
1623
1624 switch (retn) {
1625 case RAGETTINGf: {
1626 do {
1627 RaFilterIndex = ((RaFilterIndex + 1) > ARGUS_DISPLAY_FILTER) ? ARGUS_REMOTE_FILTER : RaFilterIndex + 1;
1628 switch (RaFilterIndex) {
1629 case ARGUS_REMOTE_FILTER:
1630 if (ArgusParser->ArgusRemoteFilter) {
1631 sprintf (RaCommandInputStr, "remote %s ", ArgusParser->ArgusRemoteFilter);
1632 RaCommandIndex = strlen(RaCommandInputStr);
1633 RaFilterIndex = ARGUS_REMOTE_FILTER;
1634 RaWindowImmediate = TRUE;
1635 done++;
1636 break;
1637 }
1638
1639 case ARGUS_LOCAL_FILTER:
1640 if (ArgusParser->ArgusLocalFilter) {
1641 sprintf (RaCommandInputStr, "local %s ", ArgusParser->ArgusLocalFilter);
1642 RaCommandIndex = strlen(RaCommandInputStr);
1643 RaFilterIndex = ARGUS_LOCAL_FILTER;
1644 RaWindowImmediate = TRUE;
1645 done++;
1646 break;
1647 }
1648 case ARGUS_DISPLAY_FILTER:
1649 if (ArgusParser->ArgusDisplayFilter) {
1650 sprintf (RaCommandInputStr, "display %s ", ArgusParser->ArgusDisplayFilter);
1651 RaCommandIndex = strlen(RaCommandInputStr);
1652 RaFilterIndex = ARGUS_DISPLAY_FILTER;
1653 RaWindowImmediate = TRUE;
1654 done++;
1655 break;
1656 }
1657 }
1658 } while ((start != RaFilterIndex) && !done);
1659 break;
1660 }
1661
1662 default: {
1663 RaWindowCursorY--;
1664 if (RaWindowCursorY < 1) {
1665 RaWindowCursorY = 1;
1666 if (RaWindowStartLine > 0) {
1667 RaWindowStartLine--;
1668 wscrl(RaCurrentWindow->window, -1);
1669 ArgusTouchScreen();
1670 } else
1671 beep();
1672 }
1673 break;
1674 }
1675 }
1676
1677 #ifdef ARGUSDEBUG
1678 ArgusDebug (1, "ArgusProcessKeyUp(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1679 #endif
1680
1681 return (retn);
1682 }
1683
1684 int
ArgusProcessKeyDown(WINDOW * win,int status,int ch)1685 ArgusProcessKeyDown (WINDOW *win, int status, int ch)
1686 {
1687 int retn = status;
1688 int trips = 0, done = 0, start = RaFilterIndex;
1689
1690 switch (retn) {
1691 case RAGETTINGf: {
1692 do {
1693 RaFilterIndex = ((RaFilterIndex - 1) < ARGUS_REMOTE_FILTER) ? ARGUS_DISPLAY_FILTER : RaFilterIndex - 1;
1694 switch (RaFilterIndex) {
1695 case ARGUS_DISPLAY_FILTER:
1696 if (ArgusParser->ArgusDisplayFilter) {
1697 sprintf (RaCommandInputStr, " display %s", ArgusParser->ArgusDisplayFilter);
1698 RaCommandIndex = strlen(RaCommandInputStr);
1699 RaFilterIndex = ARGUS_DISPLAY_FILTER;
1700 RaWindowImmediate = TRUE;
1701 done++;
1702 break;
1703 }
1704
1705 case ARGUS_LOCAL_FILTER:
1706 if (ArgusParser->ArgusLocalFilter) {
1707 sprintf (RaCommandInputStr, " local %s", ArgusParser->ArgusLocalFilter);
1708 RaCommandIndex = strlen(RaCommandInputStr);
1709 RaFilterIndex = ARGUS_LOCAL_FILTER;
1710 RaWindowImmediate = TRUE;
1711 done++;
1712 break;
1713 }
1714
1715 case ARGUS_REMOTE_FILTER:
1716 if (ArgusParser->ArgusRemoteFilter) {
1717 sprintf (RaCommandInputStr, " remote %s", ArgusParser->ArgusRemoteFilter);
1718 RaCommandIndex = strlen(RaCommandInputStr);
1719 RaFilterIndex = ARGUS_REMOTE_FILTER;
1720 RaWindowImmediate = TRUE;
1721 done++;
1722 break;
1723 }
1724 }
1725 trips++;
1726 } while ((start != RaFilterIndex) && !done && (trips < 3));
1727 break;
1728 }
1729 default: {
1730 RaWindowCursorY++;
1731 if ((RaCursesProcess->queue->count - RaWindowStartLine) < RaDisplayLines) {
1732 int maxwincount = RaCursesProcess->queue->count - RaWindowStartLine;
1733 if (RaWindowCursorY > maxwincount) {
1734 RaWindowCursorY = maxwincount;
1735 beep();
1736 }
1737
1738 } else {
1739 if (RaWindowCursorY > RaDisplayLines) {
1740 if ((RaCursesProcess->queue->count - RaWindowStartLine) > RaDisplayLines) {
1741 RaWindowStartLine++;
1742 wscrl(RaCurrentWindow->window, 1);
1743 ArgusTouchScreen();
1744 } else
1745 beep();
1746
1747 RaWindowCursorY = RaDisplayLines;
1748 }
1749 }
1750 break;
1751 }
1752 }
1753
1754 #ifdef ARGUSDEBUG
1755 ArgusDebug (1, "ArgusProcessKeyDown(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1756 #endif
1757 return (retn);
1758 }
1759
1760 int
ArgusProcessKeyLeft(WINDOW * win,int status,int ch)1761 ArgusProcessKeyLeft (WINDOW *win, int status, int ch)
1762 {
1763 int retn = status;
1764
1765 if (++RaCursorOffset > RaCommandIndex)
1766 RaCursorOffset = RaCommandIndex;
1767
1768 #ifdef ARGUSDEBUG
1769 ArgusDebug (1, "ArgusProcessKeyLeft(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1770 #endif
1771 return (retn);
1772 }
1773
1774 int
ArgusProcessKeyRight(WINDOW * win,int status,int ch)1775 ArgusProcessKeyRight (WINDOW *win, int status, int ch)
1776 {
1777 int retn = status;
1778
1779 if (--RaCursorOffset < 0)
1780 RaCursorOffset = 0;
1781
1782 #ifdef ARGUSDEBUG
1783 ArgusDebug (1, "ArgusProcessKeyRight(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1784 #endif
1785 return (retn);
1786 }
1787
1788 int
ArgusProcessBell(WINDOW * win,int status,int ch)1789 ArgusProcessBell (WINDOW *win, int status, int ch)
1790 {
1791 int retn = status;
1792
1793 ArgusDisplayStatus = (ArgusDisplayStatus ? 0 : 1);
1794 ArgusZeroDebugString();
1795 if (ArgusParser->Pauseflag)
1796 ArgusSetDebugString ("Paused", LOG_ERR, ARGUS_LOCK);
1797 ArgusTouchScreen();
1798
1799 #ifdef ARGUSDEBUG
1800 ArgusDebug (1, "ArgusProcessBell(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1801 #endif
1802 return (retn);
1803 }
1804
1805 int
ArgusProcessBackspace(WINDOW * win,int status,int ch)1806 ArgusProcessBackspace (WINDOW *win, int status, int ch)
1807 {
1808 int retn = status;
1809
1810 if (RaCursorOffset == 0) {
1811 RaCommandInputStr[RaCommandIndex--] = '\0';
1812 RaCommandInputStr[RaCommandIndex] = '\0';
1813 } else {
1814 if (RaCursorOffset < RaCommandIndex) {
1815 int z, start;
1816 start = RaCommandIndex - (RaCursorOffset + 1);
1817 if (start < 0)
1818 start = 0;
1819 for (z = start; z < (RaCommandIndex - 1); z++)
1820 RaCommandInputStr[z] = RaCommandInputStr[z + 1];
1821 RaCommandInputStr[RaCommandIndex--] = '\0';
1822 RaCommandInputStr[RaCommandIndex] = '\0';
1823 if (RaCursorOffset > RaCommandIndex)
1824 RaCursorOffset = RaCommandIndex;
1825 }
1826 }
1827
1828 if (RaCommandIndex < 0)
1829 RaCommandIndex = 0;
1830
1831 #ifdef ARGUSDEBUG
1832 ArgusDebug (1, "ArgusProcessBackspace(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1833 #endif
1834 return (retn);
1835 }
1836
1837
1838 int
ArgusProcessDeleteLine(WINDOW * win,int status,int ch)1839 ArgusProcessDeleteLine (WINDOW *win, int status, int ch)
1840 {
1841 int retn = status;
1842
1843 bzero (RaCommandInputStr, MAXSTRLEN);
1844 RaCommandIndex = 0;
1845 RaCursorOffset = 0;
1846
1847 #ifdef ARGUSDEBUG
1848 ArgusDebug (1, "ArgusProcessDeleteLine(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch);
1849 #endif
1850 return (retn);
1851 }
1852
1853
1854 int
ArgusProcessCharacter(WINDOW * win,int status,int ch)1855 ArgusProcessCharacter(WINDOW *win, int status, int ch)
1856 {
1857 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
1858 struct ArgusParserStruct *parser = ArgusParser;
1859 int retn = status, x;
1860
1861 int iter;
1862 if (retn == RAGOTslash) {
1863 if (isdigit(ch) && (ch != '0')) {
1864 if (RaDigitPtr < 16)
1865 RaDigitBuffer[RaDigitPtr++] = ch;
1866 } else {
1867 if (RaDigitPtr) {
1868 char *ptr;
1869 RaIter= strtol(RaDigitBuffer, (char **)&ptr, 10);
1870 if (ptr == RaDigitBuffer)
1871 RaIter = 1;
1872 bzero(RaDigitBuffer, sizeof(RaDigitBuffer));
1873 RaDigitPtr = 0;
1874 } else
1875 RaIter = 1;
1876
1877 #if defined(ARGUSDEBUG)
1878 ArgusDebug (6, "ArgusProcessCommand: calling with %d iterations\n", RaIter);
1879 #endif
1880 }
1881 } else
1882 RaIter = 1;
1883
1884 for (iter = 0; iter < RaIter; iter++) {
1885 int olddir = -1;
1886
1887 switch (retn) {
1888 case RAGOTcolon:
1889 case RAGOTslash: {
1890 ArgusZeroDebugString();
1891 switch (ch) {
1892 case 0x07: {
1893 ArgusDisplayStatus = (ArgusDisplayStatus ? 0 : 1);
1894 ArgusTouchScreen();
1895 break;
1896 }
1897 case '%': {
1898 ArgusParser->Pctflag = (ArgusParser->Pctflag == 1) ? 0 : 1;
1899 if (ArgusParser->Pctflag)
1900 RaInputString = "Toggle percent on";
1901 else
1902 RaInputString = "Toggle percent off";
1903 ArgusTouchScreen();
1904 break;
1905 }
1906 case 'A':
1907 ArgusParser->Aflag = ArgusParser->Aflag ? 0 : 1;
1908 break;
1909 case 'H':
1910 ArgusParser->Hflag = ArgusParser->Hflag ? 0 : 1;
1911 break;
1912 case 'P': {
1913 ArgusParser->Pauseflag = (ArgusParser->Pauseflag > 0.0) ? 0.0 : 1.0;
1914 if (ArgusParser->Pauseflag)
1915 ArgusSetDebugString ("Paused", LOG_ERR, ARGUS_LOCK);
1916 break;
1917 }
1918 case 'v':
1919 if (ArgusParser->vflag) {
1920 ArgusParser->vflag = 0;
1921 ArgusReverseSortDir = 0;
1922 } else {
1923 ArgusParser->vflag = 1;
1924 ArgusReverseSortDir++;
1925 }
1926 RaClientSortQueue(ArgusSorter, queue, ARGUS_LOCK);
1927 break;
1928
1929 case 'N':
1930 olddir = ArgusSearchDirection;
1931 ArgusSearchDirection = (ArgusSearchDirection == ARGUS_FORWARD) ? ARGUS_BACKWARD : ARGUS_FORWARD;
1932 case 'n': {
1933 char *ArgusSearchString = ArgusParser->ArgusSearchString, sbuf[1024];
1934
1935 if ((retn == RAGOTslash) && ((ArgusSearchString != NULL) && strlen(ArgusSearchString))) {
1936 int cursx = RaWindowCursorX, cursy = RaWindowCursorY + RaWindowStartLine;
1937 int linenum;
1938 #if defined(ARGUS_THREADS)
1939 pthread_mutex_lock(&RaCursesLock);
1940 #endif
1941 if ((linenum = RaSearchDisplay(ArgusParser, queue, ArgusSearchDirection, &cursx, &cursy, ArgusSearchString, ARGUS_LOCK)) < 0) {
1942 if (ArgusSearchDirection == ARGUS_FORWARD) {
1943 sprintf (sbuf, "search hit BOTTOM, continuing at TOP");
1944 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1945 cursx = 0; cursy = 0;
1946 } else {
1947 sprintf (sbuf, "search hit TOP, continuing at BOTTOM");
1948 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
1949 cursx = RaScreenColumns; cursy = queue->count;
1950 }
1951 linenum = RaSearchDisplay(ArgusParser, queue, ArgusSearchDirection, &cursx, &cursy, ArgusSearchString, ARGUS_LOCK);
1952 }
1953 if (linenum >= 0) {
1954 if ((linenum < RaWindowStartLine) || ((linenum > RaWindowStartLine + RaDisplayLines))) {
1955 int startline = ((cursy - 1)/ RaDisplayLines) * RaDisplayLines;
1956 startline = (queue->count > startline) ? startline : queue->count - RaDisplayLines;
1957 startline = (startline > 0) ? startline : 0;
1958 RaWindowStartLine = startline;
1959
1960 if ((RaWindowCursorY = cursy % RaDisplayLines) == 0)
1961 RaWindowCursorY = RaDisplayLines;
1962
1963 } else
1964 RaWindowCursorY = cursy - RaWindowStartLine;
1965
1966 RaWindowCursorX = cursx;
1967 ArgusUpdateScreen();
1968 }
1969 #if defined(ARGUS_THREADS)
1970 pthread_mutex_unlock(&RaCursesLock);
1971 #endif
1972 }
1973 if (olddir != -1)
1974 ArgusSearchDirection = olddir;
1975 break;
1976 }
1977
1978 case KEY_LEFT:
1979 case 'h': {
1980 RaWindowCursorX--;
1981 if (RaWindowCursorX < 0) {
1982 RaWindowCursorX = 0;
1983 beep();
1984 }
1985 ArgusTouchScreen();
1986 break;
1987 }
1988 case 'j':
1989 case 0x05:
1990 case 0x0E:
1991 case KEY_DOWN: {
1992 RaWindowCursorY++;
1993 if ((queue->count - RaWindowStartLine) < RaDisplayLines) {
1994 int maxwincount = queue->count - RaWindowStartLine;
1995 if (RaWindowCursorY > maxwincount) {
1996 RaWindowCursorY = maxwincount;
1997 beep();
1998 }
1999
2000 } else {
2001 if (RaWindowCursorY > RaDisplayLines) {
2002 if ((queue->count - RaWindowStartLine) > RaDisplayLines) {
2003 RaWindowStartLine++;
2004 wscrl(RaCurrentWindow->window, 1);
2005 } else
2006 beep();
2007
2008 RaWindowCursorY = RaDisplayLines;
2009 }
2010 }
2011 ArgusTouchScreen();
2012 ArgusSearchHitRank = 0;
2013 break;
2014 }
2015
2016 case 0x19:
2017 case KEY_UP:
2018 case 'k': {
2019 RaWindowCursorY--;
2020 if (RaWindowCursorY < 1) {
2021 RaWindowCursorY = 1;
2022 if (RaWindowStartLine > 0) {
2023 RaWindowStartLine--;
2024 wscrl(RaCurrentWindow->window, -1);
2025 ArgusTouchScreen();
2026 } else
2027 beep();
2028 }
2029 ArgusTouchScreen();
2030 ArgusSearchHitRank = 0;
2031 break;
2032 }
2033
2034 case KEY_RIGHT:
2035 case 'l': {
2036 RaWindowCursorX++;
2037 if (RaWindowCursorX >= RaScreenColumns) {
2038 RaWindowCursorX = RaScreenColumns - 1;
2039 beep();
2040 }
2041 ArgusTouchScreen();
2042 ArgusSearchHitRank = 0;
2043 break;
2044 }
2045
2046 case 'g':
2047 case KEY_HOME:
2048 if ((RaWindowStartLine != 0) || ((RaWindowCursorX != 0) || (RaWindowCursorY != 0))) {
2049 RaWindowStartLine = 0;
2050 RaWindowCursorX = 0;
2051 RaWindowCursorY = 1;
2052 ArgusTouchScreen();
2053 ArgusSearchHitRank = 0;
2054 } else
2055 beep();
2056 break;
2057
2058 case 'G':
2059 case KEY_END:
2060 if (RaWindowStartLine != (queue->count - RaDisplayLines)) {
2061 RaWindowStartLine = queue->count - RaDisplayLines;
2062 if (RaWindowStartLine < 0)
2063 RaWindowStartLine = 0;
2064 RaWindowCursorX = 0;
2065 RaWindowCursorY = queue->count - RaWindowStartLine;
2066 if (RaWindowCursorY >= RaDisplayLines)
2067 RaWindowCursorY = RaDisplayLines - 1;
2068 ArgusTouchScreen();
2069 ArgusSearchHitRank = 0;
2070 } else
2071 beep();
2072 break;
2073
2074 case 0x06:
2075 case 0x04:
2076 case ' ':
2077 case KEY_NPAGE: {
2078 int count = (RaSortItems - RaWindowStartLine) - 1;
2079 if (count > RaDisplayLines) {
2080 RaWindowStartLine += RaDisplayLines - 1;
2081 wscrl(RaCurrentWindow->window, RaDisplayLines - 1);
2082 if ((count = (RaSortItems - RaWindowStartLine) - 1) < RaDisplayLines) {
2083 wmove(win, count + 2, 0);
2084 wclrtobot(win);
2085 }
2086
2087 } else {
2088 if (count) {
2089 RaWindowStartLine += count;
2090 wscrl(RaCurrentWindow->window, count);
2091 wmove(win, count + 2, 0);
2092 wclrtobot(win);
2093 } else
2094 beep();
2095 }
2096 ArgusTouchScreen();
2097 break;
2098 }
2099
2100 case 0x02:
2101 case 0x15:
2102 case KEY_PPAGE:
2103 if (RaWindowStartLine > 0) {
2104 wscrl(RaCurrentWindow->window, (RaDisplayLines > RaWindowStartLine) ? -RaWindowStartLine : -(RaDisplayLines - 1));
2105 RaWindowStartLine -= (RaDisplayLines - 1);
2106 if (RaWindowStartLine < 0)
2107 RaWindowStartLine = 0;
2108 } else
2109 beep();
2110 ArgusTouchScreen();
2111 break;
2112
2113 case 'b': {
2114 int startline = RaWindowCursorY + RaWindowStartLine;
2115 struct ArgusRecordStruct *ns;
2116
2117 if (RaWindowCursorX == 0) {
2118 if (RaWindowCursorY > 1) {
2119 RaWindowCursorY--;
2120 } else {
2121 if (RaWindowStartLine > 0) {
2122 RaWindowStartLine--;
2123 } else {
2124 beep();
2125 break;
2126 }
2127 }
2128
2129 startline = RaWindowCursorY + RaWindowStartLine;
2130 if (startline == 0) {
2131 startline = 1;
2132 }
2133 }
2134
2135 if (RaSortItems >= startline) {
2136 if ((ns = (struct ArgusRecordStruct *) queue->array[startline - 1]) != NULL) {
2137 char buf[MAXSTRLEN], *ptr;
2138
2139 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != startline)) {
2140 if (ns->disp.str != NULL)
2141 free(ns->disp.str);
2142
2143 buf[0] = '\0';
2144 ns->rank = startline;
2145 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
2146 ns->disp.str = strdup(buf);
2147 ns->status &= ~ARGUS_RECORD_MODIFIED;
2148 }
2149
2150 bcopy(ns->disp.str, buf, strlen(ns->disp.str) + 1);
2151
2152 if (RaWindowCursorX == 0)
2153 RaWindowCursorX = strlen(buf) - 1;
2154
2155 if ((ptr = &buf[RaWindowCursorX]) != NULL) {
2156 while ((ptr > buf) && isspace((int)*(ptr - 1)))
2157 ptr--;
2158
2159 if (ispunct((int)*(--ptr))) {
2160 while ((ptr > buf) && ispunct((int)*(ptr - 1)))
2161 ptr--;
2162 } else {
2163 while ((ptr > buf) && !(isspace((int)*(ptr - 1)) || ispunct((int)*(ptr - 1))))
2164 ptr--;
2165 }
2166 RaWindowCursorX = ptr - buf;
2167 }
2168 }
2169 }
2170 ArgusTouchScreen();
2171 ArgusSearchHitRank = 0;
2172 break;
2173 }
2174
2175 case 'w': {
2176 int startline = RaWindowCursorY + RaWindowStartLine;
2177 struct ArgusRecordStruct *ns;
2178
2179 if (startline == 0)
2180 startline = 1;
2181
2182 if (RaSortItems >= startline) {
2183 int done = 0;
2184 int shifted = 0;
2185
2186 while (!done) {
2187 if ((ns = (struct ArgusRecordStruct *) queue->array[startline - 1]) != NULL) {
2188 char buf[MAXSTRLEN], *ptr;
2189 int cursor, passpunct = 0;
2190
2191 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != startline)) {
2192 if (ns->disp.str != NULL)
2193 free(ns->disp.str);
2194
2195 buf[0] = '\0';
2196 ns->rank = startline;
2197 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
2198 ns->disp.str = strdup(buf);
2199 ns->status &= ~ARGUS_RECORD_MODIFIED;
2200 }
2201
2202 bcopy(ns->disp.str, buf, strlen(ns->disp.str) + 1);
2203
2204 if (!shifted) {
2205 cursor = RaWindowCursorX + 1;
2206 if (ispunct((int)buf[RaWindowCursorX]))
2207 passpunct = 1;
2208 } else
2209 cursor = RaWindowCursorX;
2210
2211 if ((ptr = &buf[cursor]) != NULL) {
2212 if (!shifted)
2213 while ((*ptr != '\0') && !(isspace((int)*ptr)) && (passpunct ? ispunct((int)*ptr) : !(ispunct((int)*ptr))))
2214 ptr++;
2215 while (isspace((int)*ptr) && (*ptr != '\0'))
2216 ptr++;
2217 if (*ptr != '\0') {
2218 RaWindowCursorX = ptr - buf;
2219 done++;
2220 } else {
2221 if (RaWindowCursorY == RaDisplayLines) {
2222 if (queue->array[startline] != NULL) {
2223 shifted++;
2224 startline++;
2225 RaWindowStartLine++;
2226 ArgusTouchScreen();
2227 RaWindowCursorX = 0;
2228 }
2229 } else {
2230 shifted++;
2231 startline++;
2232 RaWindowCursorY++;
2233 RaWindowCursorX = 0;
2234 }
2235 }
2236 }
2237 }
2238 }
2239 ArgusSearchHitRank = 0;
2240 }
2241 ArgusTouchScreen();
2242 break;
2243 }
2244
2245 case '0':
2246 case '^': {
2247 RaWindowCursorX = 0;
2248 ArgusTouchScreen();
2249 ArgusSearchHitRank = 0;
2250 break;
2251 }
2252 case '$': {
2253 int startline = RaWindowCursorY + RaWindowStartLine;
2254 struct ArgusRecordStruct *ns;
2255
2256 if (startline == 0)
2257 startline = 1;
2258
2259 if (RaSortItems >= startline) {
2260 if ((ns = (struct ArgusRecordStruct *) queue->array[startline - 1]) != NULL) {
2261 char buf[MAXSTRLEN];
2262 int len = strlen(ns->disp.str);
2263
2264 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != startline)) {
2265 if (ns->disp.str != NULL)
2266 free(ns->disp.str);
2267
2268 buf[0] = '\0';
2269 ns->rank = startline;
2270 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
2271 ns->disp.str = strdup(buf);
2272 ns->status &= ~ARGUS_RECORD_MODIFIED;
2273 }
2274
2275 len = strlen(ns->disp.str);
2276 bcopy(ns->disp.str, buf, len + 1);
2277 if ((RaWindowCursorX = len - 1) < 0)
2278 RaWindowCursorX = 0;
2279 }
2280 }
2281 ArgusTouchScreen();
2282 ArgusSearchHitRank = 0;
2283 break;
2284 }
2285
2286 case '?':
2287 RaCursesSetWindowFocus(ArgusParser, RaStatusWindow);
2288 #if defined(ARGUS_READLINE)
2289 argus_getsearch_string(ARGUS_BACKWARD);
2290 #else
2291 retn = RAGETTINGslash;
2292 RaInputString = "?";
2293 ArgusSearchDirection = ARGUS_BACKWARD;
2294 bzero(RaCommandInputStr, MAXSTRLEN);
2295 RaCommandIndex = 0;
2296 RaWindowCursorX = 0;
2297 #endif
2298 break;
2299
2300 case '/':
2301 RaCursesSetWindowFocus(ArgusParser, RaStatusWindow);
2302 #if defined(ARGUS_READLINE)
2303 argus_getsearch_string(ARGUS_FORWARD);
2304 #else
2305 retn = RAGETTINGslash;
2306 RaInputString = "/";
2307 ArgusSearchDirection = ARGUS_FORWARD;
2308 bzero(RaCommandInputStr, MAXSTRLEN);
2309 RaCommandIndex = 0;
2310 RaWindowCursorX = 0;
2311 #endif
2312 break;
2313
2314 case ':': {
2315 RaCursesSetWindowFocus(ArgusParser, RaStatusWindow);
2316 #if defined(ARGUS_READLINE)
2317 argus_command_string();
2318 #else
2319 retn = RAGETTINGcolon;
2320 RaInputString = ":";
2321 bzero(RaCommandInputStr, MAXSTRLEN);
2322 RaCommandIndex = 0;
2323 RaWindowCursorX = 0;
2324 #endif
2325 break;
2326 }
2327 }
2328 break;
2329 }
2330
2331 case RAGETTINGq:
2332 if (*RaCommandInputStr == 'y') {
2333 RaParseComplete(SIGINT);
2334 } else {
2335 retn = RAGOTslash;
2336 RaInputString = RANEWCOMMANDSTR;
2337 RaCommandInputStr[0] = '\0';
2338 RaCommandIndex = 0;
2339 }
2340 break;
2341
2342
2343 case RAGETTINGcolon: {
2344 if (RaCommandIndex == 0) {
2345 switch (ch) {
2346 case '%': {
2347 ArgusParser->Pctflag = (ArgusParser->Pctflag == 1) ? 0 : 1;
2348 if (ArgusParser->Pctflag)
2349 RaInputString = "Toggle percent on";
2350 else
2351 RaInputString = "Toggle percent off";
2352 break;
2353 }
2354
2355 case 'a': {
2356 retn = RAGETTINGa;
2357 RaInputString = RAGETTINGaSTR;
2358 break;
2359 }
2360
2361 case 'A':
2362 ArgusParser->Aflag = ArgusParser->Aflag ? 0 : 1;
2363 break;
2364
2365 case 'c': {
2366 break;
2367 }
2368
2369 case 'd': {
2370 retn = RAGETTINGd;
2371 RaInputString = RAGETTINGdSTR;
2372
2373 if (ArgusParser->ArgusRemoteHostList) {
2374 struct ArgusInput *input = (void *)ArgusParser->ArgusActiveHosts->start;
2375 do {
2376 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s:%d", input->hostname, input->portnum);
2377 RaCommandIndex = strlen(RaCommandInputStr);
2378 input = (void *)input->qhdr.nxt;
2379 } while (input != (void *)ArgusParser->ArgusActiveHosts->start);
2380 }
2381
2382 break;
2383 }
2384
2385 case 'D': {
2386 retn = RAGETTINGD;
2387 RaInputString = RAGETTINGDSTR;
2388 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d", ArgusParser->debugflag);
2389 RaCommandIndex = strlen(RaCommandInputStr);
2390 break;
2391 }
2392
2393 case 'e': {
2394 retn = RAGETTINGe;
2395 RaInputString = RAGETTINGeSTR;
2396 if (ArgusParser->estr) {
2397 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", ArgusParser->estr);
2398 }
2399 RaCommandIndex = strlen(RaCommandInputStr);
2400 break;
2401 }
2402
2403 case 'f': {
2404 retn = RAGETTINGf;
2405 RaInputString = RAGETTINGfSTR;
2406 RaFilterIndex = 3;
2407 if (ArgusParser->ArgusRemoteFilter) {
2408 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " remote %s", ArgusParser->ArgusRemoteFilter);
2409 RaFilterIndex = ARGUS_REMOTE_FILTER;
2410 } else
2411 if (ArgusParser->ArgusLocalFilter) {
2412 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " local %s", ArgusParser->ArgusLocalFilter);
2413 RaFilterIndex = ARGUS_LOCAL_FILTER;
2414 } else
2415 if (ArgusParser->ArgusDisplayFilter) {
2416 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " display %s", ArgusParser->ArgusDisplayFilter);
2417 RaFilterIndex = ARGUS_DISPLAY_FILTER;
2418 }
2419 RaCommandIndex = strlen(RaCommandInputStr);
2420 break;
2421 }
2422
2423 case 'm': {
2424 struct ArgusAggregatorStruct *agg = parser->ArgusAggregator;
2425 struct ArgusMaskStruct *ArgusMaskDefs = ArgusIpV4MaskDefs;
2426 int i;
2427
2428 retn = RAGETTINGm;
2429 RaInputString = RAGETTINGmSTR;
2430
2431 if (agg->modeStr != NULL) {
2432 sprintf (RaCommandInputStr, "%s", agg->modeStr);
2433 } else {
2434 for (i = 0; i < ARGUS_MAX_MASK_LIST; i++) {
2435 if (agg->mask & (0x01LL << i)) {
2436 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s", ArgusMaskDefs[i].name);
2437
2438 switch (i) {
2439 case ARGUS_MASK_SADDR:
2440 if (agg->saddrlen > 0)
2441 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "/%d", agg->saddrlen);
2442 break;
2443 case ARGUS_MASK_DADDR:
2444 if (agg->daddrlen > 0)
2445 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "/%d", agg->daddrlen);
2446 break;
2447 }
2448 }
2449 }
2450
2451 agg->modeStr = strdup(RaCommandInputStr);
2452 }
2453
2454 RaCommandIndex = strlen(RaCommandInputStr);
2455 break;
2456 }
2457
2458 case 'M': {
2459 struct ArgusModeStruct *mode;
2460 retn = RAGETTINGM;
2461 RaInputString = RAGETTINGMSTR;
2462
2463 if ((mode = ArgusParser->ArgusModeList) != NULL) {
2464 while (mode) {
2465 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s", mode->mode);
2466 mode = mode->nxt;
2467 }
2468 }
2469 RaCommandIndex = strlen(RaCommandInputStr);
2470 break;
2471 }
2472
2473 case 'n':
2474 retn = RAGETTINGn;
2475 RaInputString = RAGETTINGnSTR;
2476 break;
2477
2478 case 'N':
2479 retn = RAGETTINGN;
2480 RaInputString = RAGETTINGNSTR;
2481 break;
2482
2483 case 'p': {
2484 retn = RAGETTINGp;
2485 RaInputString = RAGETTINGpSTR;
2486 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d", ArgusParser->pflag);
2487 RaCommandIndex = strlen(RaCommandInputStr);
2488 break;
2489 }
2490
2491 case 'P': {
2492 ArgusParser->Pauseflag = (ArgusParser->Pauseflag > 0.0) ? 0.0 : 1.0;
2493 if (ArgusParser->Pauseflag)
2494 ArgusSetDebugString ("Paused", LOG_ERR, ARGUS_LOCK);
2495 break;
2496 }
2497
2498 case 't':
2499 retn = RAGETTINGt;
2500 RaInputString = RAGETTINGtSTR;
2501 if (ArgusParser->timearg) {
2502 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", ArgusParser->timearg);
2503 }
2504 RaCommandIndex = strlen(RaCommandInputStr);
2505 break;
2506
2507 case 'T':
2508 retn = RAGETTINGT;
2509 RaInputString = RAGETTINGTSTR;
2510 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d.%06d",
2511 (int)ArgusParser->timeout.tv_sec, (int)ArgusParser->timeout.tv_usec);
2512 RaCommandIndex = strlen(RaCommandInputStr);
2513 break;
2514
2515 case 'R': {
2516 struct ArgusInput *input = ArgusParser->ArgusInputFileList;
2517 retn = RAGETTINGR;
2518 RaInputString = RAGETTINGRSTR;
2519 while (input) {
2520 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s", input->filename);
2521 RaCommandIndex = strlen(RaCommandInputStr);
2522 input = (void *)input->qhdr.nxt;
2523 }
2524 break;
2525 }
2526
2527 case 'r': {
2528 struct ArgusInput *input = ArgusParser->ArgusInputFileList;
2529 retn = RAGETTINGr;
2530 RaInputString = RAGETTINGrSTR;
2531 while (input) {
2532 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s", input->filename);
2533 RaCommandIndex = strlen(RaCommandInputStr);
2534 input = (void *)input->qhdr.nxt;
2535 }
2536 break;
2537 }
2538
2539 case 'S': {
2540 struct ArgusInput *input = ArgusParser->ArgusRemoteHostList;
2541 retn = RAGETTINGS;
2542 RaInputString = RAGETTINGSSTR;
2543 while (input) {
2544 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " %s:%d", input->hostname, input->portnum);
2545 RaCommandIndex = strlen(RaCommandInputStr);
2546 input = (void *)input->qhdr.nxt;
2547 }
2548 break;
2549 }
2550
2551 case 's': {
2552 int x, y;
2553 retn = RAGETTINGs;
2554 RaInputString = RAGETTINGsSTR;
2555 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++) {
2556 if (ArgusSorter->ArgusSortAlgorithms[x]) {
2557 for (y = 0; y < ARGUS_MAX_SORT_ALG; y++) {
2558 if (ArgusSorter->ArgusSortAlgorithms[x] == ArgusSortAlgorithmTable[y]) {
2559 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s ",
2560 ArgusSortKeyWords[y]);
2561 break;
2562 }
2563 }
2564 }
2565 }
2566 RaCommandIndex = strlen(RaCommandInputStr);
2567 break;
2568 }
2569
2570 case 'u':
2571 retn = RAGETTINGu;
2572 RaInputString = RAGETTINGuSTR;
2573 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d.", (int) RaCursesUpdateInterval.tv_sec);
2574 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%06d",(int) RaCursesUpdateInterval.tv_usec);
2575 RaCommandIndex = strlen(RaCommandInputStr);
2576 break;
2577
2578 case 'U':
2579 retn = RAGETTINGU;
2580 RaInputString = RAGETTINGUSTR;
2581 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%2.2f", RaUpdateRate);
2582 RaCommandIndex = strlen(RaCommandInputStr);
2583 break;
2584
2585 case 'w':
2586 retn = RAGETTINGw;
2587 RaInputString = RAGETTINGwSTR;
2588 break;
2589
2590 case 'F': {
2591 retn = RAGETTINGF;
2592 RaInputString = RAGETTINGFSTR;
2593
2594 for (x = 0; x < MAX_PRINT_ALG_TYPES; x++) {
2595 int y;
2596 if (parser->RaPrintAlgorithmList[x] != NULL) {
2597 for (y = 0; y < MAX_PRINT_ALG_TYPES; y++) {
2598 if ((void *) parser->RaPrintAlgorithmList[x]->print == (void *) RaPrintAlgorithmTable[y].print) {
2599 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s:%d ",
2600 RaPrintAlgorithmTable[y].field, RaPrintAlgorithmTable[y].length);
2601 break;
2602 }
2603 }
2604 } else
2605 break;
2606 }
2607 RaCommandIndex = strlen(RaCommandInputStr);
2608 break;
2609 }
2610
2611 case 'Q':
2612 retn = RAGETTINGq;
2613 RaInputString = RAGETTINGqSTR;
2614 break;
2615
2616 case 'H':
2617 ArgusParser->Hflag = ArgusParser->Hflag ? 0 : 1;
2618 break;
2619
2620 case 'h':
2621 retn = RAGETTINGh;
2622 RaInputString = RAGETTINGhSTR;
2623 RaWindowStatus = 0;
2624 RaOutputHelpScreen();
2625 break;
2626
2627 case 'v':
2628 if (ArgusParser->vflag) {
2629 ArgusParser->vflag = 0;
2630 ArgusReverseSortDir = 0;
2631 } else {
2632 ArgusParser->vflag = 1;
2633 ArgusReverseSortDir++;
2634 }
2635
2636 RaClientSortQueue(ArgusSorter, queue, ARGUS_LOCK);
2637 break;
2638
2639 case '=': {
2640 struct ArgusRecordStruct *ns = NULL;
2641
2642 werase(RaCurrentWindow->window);
2643 ArgusTouchScreen();
2644 #if defined(ARGUS_THREADS)
2645 pthread_mutex_lock(&queue->lock);
2646 #endif
2647 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(queue, ARGUS_NOLOCK)) != NULL) {
2648 if (ArgusSearchHitRecord == ns) {
2649 ArgusResetSearch();
2650 }
2651 ArgusDeleteRecordStruct (ArgusParser, ns);
2652 }
2653
2654 ArgusEmptyHashTable(RaCursesProcess->htable);
2655 if (ArgusParser->ns) {
2656 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
2657 ArgusParser->ns = NULL;
2658 }
2659 ArgusParser->RaClientUpdate.tv_sec = 0;
2660 ArgusParser->ArgusTotalRecords = 0;
2661 RaCursesStartTime.tv_sec = 0;
2662 RaCursesStartTime.tv_usec = 0;
2663 RaCursesStopTime.tv_sec = 0;
2664 RaCursesStopTime.tv_usec = 0;
2665
2666 #if defined(ARGUS_THREADS)
2667 pthread_mutex_unlock(&queue->lock);
2668 #endif
2669 break;
2670 }
2671
2672 case 'z':
2673 if (++ArgusParser->zflag > 1) {
2674 ArgusParser->zflag = 0;
2675 }
2676 break;
2677
2678 case 'Z':
2679 switch (ArgusParser->Zflag) {
2680 case '\0': ArgusParser->Zflag = 'b'; break;
2681 case 'b': ArgusParser->Zflag = 's'; break;
2682 case 's': ArgusParser->Zflag = 'd'; break;
2683 case 'd': ArgusParser->Zflag = '\0'; break;
2684 }
2685 break;
2686
2687 default:
2688 RaCommandInputStr[RaCommandIndex++] = ch;
2689 break;
2690
2691 }
2692 break;
2693 }
2694 }
2695
2696 default: {
2697 switch (ch) {
2698 case KEY_RIGHT:
2699 if (--RaCursorOffset < 0)
2700 RaCursorOffset = 0;
2701 break;
2702 case KEY_LEFT:
2703 if (++RaCursorOffset > RaCommandIndex)
2704 RaCursorOffset = RaCommandIndex;
2705 break;
2706
2707 default:
2708 if (isascii(ch)) {
2709 if (RaCursorOffset == 0)
2710 RaCommandInputStr[RaCommandIndex++] = ch;
2711 else {
2712 int z, start;
2713 start = RaCommandIndex - RaCursorOffset;
2714 for (z = RaCommandIndex; z > start; z--)
2715 RaCommandInputStr[z] = RaCommandInputStr[z-1];
2716
2717 RaCommandInputStr[start] = ch;
2718 RaCommandIndex++;
2719 }
2720 }
2721 }
2722 break;
2723 }
2724 }
2725
2726 if (ArgusParser->Pauseflag)
2727 ArgusSetDebugString ("Paused", LOG_ERR, ARGUS_LOCK);
2728 }
2729
2730 #ifdef ARGUSDEBUG
2731 ArgusDebug (1, "ArgusProcessCharacter(%p, 0x%x, 0x%x) returned 0x%x\n", win, status, ch, retn);
2732 #endif
2733 return (retn);
2734 }
2735
2736
2737 void
ArgusDrawWindow(struct ArgusWindowStruct * ws)2738 ArgusDrawWindow(struct ArgusWindowStruct *ws)
2739 {
2740 WINDOW *win = ws->window;
2741 if (win == RaCurrentWindow->window) {
2742 struct ArgusParserStruct *parser = ArgusParser;
2743 struct ArgusRecordStruct *ns = NULL;
2744 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
2745
2746 if ((RaWindowModified == RA_MODIFIED) || ArgusAlwaysUpdate) {
2747 int x = 0, cnt = 0;
2748
2749 #ifdef ARGUSDEBUG
2750 ArgusDebug (1, "RaDrawWindow(%p) RaWindowModified %d RaWindowStatus %d\n", ws, RaWindowModified, RaWindowStatus);
2751 #endif
2752 parser->RaLabel = NULL;
2753
2754 if (RaWindowStatus) {
2755 #if defined(ARGUS_THREADS)
2756 pthread_mutex_lock(&queue->lock);
2757 #endif
2758 if (parser->status & ARGUS_FILE_LIST_PROCESSED) {
2759 if (queue->status & RA_MODIFIED) {
2760 #ifdef ARGUSDEBUG
2761 ArgusDebug (1, "ArgusDrawWindow(%p) processing queue\n", ws);
2762 #endif
2763 RaClientSortQueue(ArgusSorter, queue, ARGUS_NOLOCK);
2764
2765 if (queue->count) {
2766 if (RaSortItems) {
2767 if (queue == RaCursesProcess->queue) {
2768 int i;
2769
2770 if (ArgusParser->ArgusAggregator != NULL) {
2771 if (ArgusParser->ns) {
2772 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
2773 ArgusParser->ns = NULL;
2774 }
2775 for (i = 0; i < queue->count; i++) {
2776 struct ArgusRecordStruct *ns;
2777 if ((ns = (struct ArgusRecordStruct *)queue->array[i]) == NULL)
2778 break;
2779 if (ArgusParser->ns)
2780 ArgusMergeRecords (ArgusParser->ArgusAggregator, ArgusParser->ns, ns);
2781 else
2782 ArgusParser->ns = ArgusCopyRecordStruct (ns);
2783 }
2784 }
2785 }
2786 }
2787 }
2788 }
2789
2790 if (queue->array != NULL) {
2791 int i, firstRow = 1;
2792
2793 if (queue->count < RaWindowStartLine) {
2794 RaWindowStartLine = queue->count - RaDisplayLines;
2795 RaWindowStartLine = (RaWindowStartLine > 0) ? RaWindowStartLine : 0;
2796 }
2797
2798 cnt = ((RaDisplayLines > 0) ? RaDisplayLines : RaWindowLines) - 1;
2799 cnt = (cnt > (queue->count - RaWindowStartLine)) ? (queue->count - RaWindowStartLine) : cnt;
2800
2801 for (x = 0, i = RaWindowStartLine; x < cnt; x++, i++) {
2802 if ((ns = (struct ArgusRecordStruct *) queue->array[i]) != NULL) {
2803 #if defined(ARGUS_COLOR_SUPPORT)
2804 int z, sz = -1, ez = 0;
2805 attr_t attr, tattr;
2806 short pair, tpair;
2807 #endif
2808
2809 if (firstRow) {
2810 #if defined(ARGUS_COLOR_SUPPORT)
2811 int attrs = 0;
2812 if (ArgusTerminalColors) {
2813 attrs = COLOR_PAIR(ARGUS_WHITE);
2814 wattron(win, attrs);
2815 }
2816 #endif
2817 if (parser->RaLabel == NULL)
2818 parser->RaLabel = ArgusGenerateLabel(parser, parser->ns);
2819
2820 mvwaddnstr (win, 0, 0, parser->RaLabel, RaScreenColumns);
2821 if (strlen(parser->RaLabel) < RaScreenColumns)
2822 wclrtoeol(win);
2823 #if defined(ARGUS_COLOR_SUPPORT)
2824 if (ArgusTerminalColors) {
2825 wattroff(win, attrs);
2826 }
2827 #endif
2828 }
2829
2830 if (ArgusAlwaysUpdate || (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != (i + 1)))) {
2831 char buf[MAXSTRLEN];
2832
2833 bzero(buf, RaScreenColumns + 1);
2834
2835 if (ns->disp.str != NULL)
2836 free(ns->disp.str);
2837
2838 ns->rank = i + 1;
2839 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
2840 ns->disp.str = strdup(buf);
2841 ns->status &= ~ARGUS_RECORD_MODIFIED;
2842 }
2843
2844 mvwprintw (win, x + 1, 0, "%s", ns->disp.str);
2845 wclrtoeol(win);
2846
2847 #if defined(ARGUS_COLOR_SUPPORT)
2848 if (ArgusTerminalColors) {
2849 if (wattr_get(win, &attr, &pair, NULL) == ERR)
2850 ArgusLog (LOG_ERR, "wattr_get failed");
2851 tattr = attr; tpair = pair;
2852
2853 ArgusGetDisplayLineColor(ArgusParser, win, ns, RaColorArray);
2854
2855 for (z = 0; z < RaScreenColumns; z++) {
2856 if (sz == -1) sz = z;
2857 if ((tattr != RaColorArray[z].attr) || (tpair != RaColorArray[z].pair)) {
2858 if (ez == 0) {
2859 tattr = RaColorArray[z].attr;
2860 tpair = RaColorArray[z].pair;
2861 } else {
2862 if ((tattr != attr) || (tpair != pair))
2863 mvwchgat(win, x + 1, sz, (ez - sz) + 1, tattr, PAIR_NUMBER(tpair), NULL);
2864 sz = z;
2865 ez = 0;
2866 }
2867 } else
2868 ez = z;
2869 }
2870
2871 if ((tattr != attr) || (tpair != pair))
2872 mvwchgat(win, x + 1, sz, (ez - sz) + 1, attr, PAIR_NUMBER(tpair), NULL);
2873 }
2874 #endif
2875 wmove(win, x + 2, 0);
2876
2877 } else
2878 break;
2879 }
2880 }
2881
2882 if (x < (RaDisplayLines - 1)) {
2883 wmove(win, x + 1, 0);
2884 wclrtobot(win);
2885 }
2886
2887 if (parser->ArgusSearchString != NULL) {
2888 if (ArgusSearchHitRecord != NULL) {
2889 int rank = ArgusSearchHitRecord->rank;
2890 if (ArgusSearchHitRank && (ArgusSearchHitRank != rank)) {
2891 #ifdef ARGUSDEBUG
2892 ArgusDebug (1, "RaSearchResults: %d was %d\n", rank, ArgusSearchHitRank);
2893 #endif
2894 if ((rank < RaWindowStartLine) || ((rank > (RaWindowStartLine + RaDisplayLines)))) {
2895 int startline = ((rank - 1)/ RaDisplayLines) * RaDisplayLines;
2896 startline = (RaCursesProcess->queue->count > startline) ? startline : RaCursesProcess->queue->count - RaDisplayLines;
2897 startline = (startline > 0) ? startline : 0;
2898 RaWindowStartLine = startline;
2899
2900 if ((RaWindowCursorY = rank % RaDisplayLines) == 0)
2901 RaWindowCursorY = RaDisplayLines;
2902
2903 } else
2904 RaWindowCursorY = rank - RaWindowStartLine;
2905 ArgusSearchHitRank = rank;
2906 }
2907
2908 } else {
2909 int linenum, cursx, cursy;
2910 char sbuf[1024];
2911
2912 cursx = RaWindowCursorX, cursy = RaWindowCursorY + RaWindowStartLine;
2913 if ((linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, parser->ArgusSearchString, ARGUS_NOLOCK)) < 0) {
2914
2915 if (ArgusSearchDirection == ARGUS_FORWARD) {
2916 sprintf (sbuf, "search hit BOTTOM, continuing at TOP");
2917 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
2918 cursx = 0; cursy = 0;
2919 } else {
2920 sprintf (sbuf, "search hit TOP, continuing at BOTTOM");
2921 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
2922 cursx = RaScreenColumns; cursy = RaCursesProcess->queue->count;
2923 }
2924 linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, parser->ArgusSearchString, ARGUS_NOLOCK);
2925 }
2926 if (linenum >= 0) {
2927 if ((linenum < RaWindowStartLine) || ((linenum > RaWindowStartLine + RaDisplayLines))) {
2928 int startline = ((cursy - 1)/ RaDisplayLines) * RaDisplayLines;
2929 startline = (RaCursesProcess->queue->count > startline) ? startline : RaCursesProcess->queue->count - RaDisplayLines;
2930 startline = (startline > 0) ? startline : 0;
2931 RaWindowStartLine = startline;
2932
2933 if ((RaWindowCursorY = cursy % RaDisplayLines) == 0)
2934 RaWindowCursorY = RaDisplayLines;
2935
2936 } else
2937 RaWindowCursorY = cursy - RaWindowStartLine;
2938
2939 RaWindowCursorX = cursx;
2940 }
2941 }
2942
2943 RaHighlightDisplay(ArgusParser, RaCursesProcess->queue, parser->ArgusSearchString);
2944 }
2945 }
2946
2947 #if defined(ARGUS_THREADS)
2948 pthread_mutex_unlock(&queue->lock);
2949 #endif
2950 }
2951 wmove(RaCurrentWindow->window, RaWindowCursorY, RaWindowCursorX);
2952 }
2953 }
2954
2955 if (win == RaHeaderWindow)
2956 RaUpdateHeaderWindow (win);
2957
2958 if (win == RaDebugWindow)
2959 RaUpdateDebugWindow (win);
2960
2961 if (win == RaStatusWindow)
2962 RaUpdateStatusWindow (win);
2963 }
2964
2965
2966 // Manage curses screen.
2967
2968
2969 void
RaResizeHandler(int sig)2970 RaResizeHandler (int sig)
2971 {
2972 RaScreenResize = TRUE;
2973
2974 #ifdef ARGUSDEBUG
2975 ArgusDebug (1, "RaResizeHandler(%d)\n", sig);
2976 #endif
2977 }
2978
2979 void
ArgusCursesProcessInit()2980 ArgusCursesProcessInit()
2981 {
2982 struct ArgusDomainStruct *dom = NULL;
2983 struct ArgusWindowStruct *ws = NULL;
2984
2985 #if defined(ARGUS_THREADS)
2986 /*
2987 sigset_t blocked_signals;
2988
2989 sigemptyset (&blocked_signals);
2990 sigaddset (&blocked_signals, SIGWINCH);
2991 pthread_sigmask(SIG_UNBLOCK, &blocked_signals, NULL);
2992 */
2993
2994 (void) signal (SIGWINCH,(void (*)(int)) RaResizeHandler);
2995 #endif
2996
2997 if (ArgusCursesEnabled)
2998 RaInitCurses();
2999
3000 if ((ArgusDomainQueue = ArgusNewQueue()) == NULL)
3001 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: RaNewQueue error %s", strerror(errno));
3002
3003 if ((ArgusWindowQueue = ArgusNewQueue()) == NULL)
3004 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: RaNewQueue error %s", strerror(errno));
3005
3006 if ((ws = (struct ArgusWindowStruct *)ArgusCalloc(1, sizeof(*ws))) == NULL)
3007 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: ArgusCalloc error %s", strerror(errno));
3008
3009 RaHeaderWindowStruct = ws;
3010 ws->window = RaHeaderWindow;
3011 ws->desc = strdup("RaHeaderWindow");
3012 ws->data = ArgusFetchWindowData;
3013 #if defined(ARGUS_THREADS)
3014 pthread_mutex_init(&ws->lock, NULL);
3015 #endif
3016 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
3017
3018 if ((ws = (struct ArgusWindowStruct *)ArgusCalloc(1, sizeof(*ws))) == NULL)
3019 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: ArgusCalloc error %s", strerror(errno));
3020
3021 RaStatusWindowStruct = ws;
3022 ws->window = RaStatusWindow;
3023 ws->desc = strdup("RaStatusWindow");
3024 ws->data = ArgusFetchWindowData;
3025 #if defined(ARGUS_THREADS)
3026 pthread_mutex_init(&ws->lock, NULL);
3027 #endif
3028 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
3029
3030 if ((ws = (struct ArgusWindowStruct *)ArgusCalloc(1, sizeof(*ws))) == NULL)
3031 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: ArgusCalloc error %s", strerror(errno));
3032
3033 RaDebugWindowStruct = ws;
3034 ws->window = RaDebugWindow;
3035 ws->desc = strdup("RaDebugWindow");
3036 ws->data = ArgusFetchWindowData;
3037 #if defined(ARGUS_THREADS)
3038 pthread_mutex_init(&ws->lock, NULL);
3039 #endif
3040 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
3041
3042 if ((ws = (struct ArgusWindowStruct *)ArgusCalloc(1, sizeof(*ws))) == NULL)
3043 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: ArgusCalloc error %s", strerror(errno));
3044
3045 RaDataWindowStruct = ws;
3046 ws->window = RaDisplayWindow;
3047 ws->desc = strdup("RaDisplayWindow");
3048 ws->data = ArgusFetchWindowData;
3049 #if defined(ARGUS_THREADS)
3050 pthread_mutex_init(&ws->lock, NULL);
3051 #endif
3052 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
3053
3054 if ((dom = (struct ArgusDomainStruct *) ArgusCalloc(1, sizeof(*dom))) == NULL)
3055 ArgusLog (LOG_ERR, "ArgusCursesProcess() ArgusCalloc error %s\n", strerror(errno));
3056
3057 dom->ws = RaDataWindowStruct;
3058 ArgusAddToQueue (ArgusDomainQueue, &dom->qhdr, ARGUS_LOCK);
3059
3060 RaCurrentWindow = RaDataWindowStruct;
3061
3062 if ((RaColorArray = (struct ArgusAttributeStruct *)ArgusCalloc(MAXSTRLEN, sizeof(*RaColorArray))) == NULL)
3063 ArgusLog(LOG_ERR, "ArgusCursesProcessInit: ArgusCalloc error %s", strerror(errno));
3064
3065 #if defined(ARGUS_THREADS)
3066 if ((pthread_create(&RaCursesInputThread, NULL, ArgusProcessCursesInput, NULL)) != 0)
3067 ArgusLog (LOG_ERR, "ArgusCursesProcess() pthread_create error %s\n", strerror(errno));
3068 #endif
3069 }
3070
3071
3072 int
ArgusFetchWindowData(struct ArgusWindowStruct * ws)3073 ArgusFetchWindowData(struct ArgusWindowStruct *ws)
3074 {
3075 int retn = 1;
3076 return(retn);
3077 }
3078
3079
3080
3081 void
ArgusCursesProcessClose()3082 ArgusCursesProcessClose()
3083 {
3084 ArgusCloseDown = 1;
3085 ArgusParser->RaParseDone = 1;
3086
3087 #if defined(ARGUS_THREADS)
3088 pthread_join(RaCursesInputThread, NULL);
3089 #endif
3090 }
3091
3092
3093 int
RaInitCurses()3094 RaInitCurses ()
3095 {
3096 char sbuf[1024];
3097 #if defined(ARGUS_CURSES) && (defined(ARGUS_READLINE) || defined(ARGUS_EDITLINE))
3098
3099 #if defined(ARGUS_READLINE)
3100 int keytimeout;
3101 #endif
3102
3103 rl_initialize();
3104 #if defined(ARGUS_HISTORY)
3105 using_history();
3106 #endif
3107 rl_redisplay_function = argus_redisplay_function;
3108 rl_getc_function = argus_getch_function;
3109
3110 #if defined(HAVE_DECL_RL_EVENT_HOOK) && HAVE_DECL_RL_EVENT_HOOK
3111 rl_event_hook = argus_readline_timeout;
3112 #endif
3113
3114 #if defined(ARGUS_READLINE)
3115 keytimeout = RaCursesUpdateInterval.tv_sec * 1000000 + RaCursesUpdateInterval.tv_usec;
3116 keytimeout = (keytimeout == 1000000) ? keytimeout - 1 : keytimeout;
3117 #if defined(HAVE_DECL_RL_SET_KEYBOARD_INPUT_TIMEOUT) && HAVE_DECL_RL_SET_KEYBOARD_INPUT_TIMEOUT
3118 rl_set_keyboard_input_timeout (keytimeout);
3119 #endif
3120 #endif
3121
3122 rl_outstream = NULL;
3123
3124 #if defined(HAVE_DECL_RL_CATCH_SIGNALS) && HAVE_DECL_RL_CATCH_SIGNALS
3125 rl_catch_signals = 0;
3126 rl_catch_sigwinch = 0;
3127 #endif
3128 #endif
3129
3130 RaCursesInit++;
3131
3132 #if HAVE_SETENV
3133 if (setenv("ESCDELAY", "0", 1) < 0) {
3134 sprintf (sbuf, "setenv(ESCDELAY, 0, 1) error %s", strerror(errno));
3135 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
3136 }
3137 #else
3138 {
3139 char buf[16];
3140 sprintf (buf, "ESCDELAY=0");
3141 if (putenv(buf) < 0) {
3142 sprintf (sbuf, "putenv(%s) error %s", buf, strerror(errno));
3143 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
3144 }
3145 }
3146 #endif
3147
3148 initscr();
3149
3150 #if defined(ARGUS_COLOR_SUPPORT)
3151 if (has_colors() == TRUE) {
3152 int colors;
3153
3154 if (ArgusParser->ArgusColorSupport) {
3155 ArgusTerminalColors++;
3156 start_color();
3157
3158 colors = COLORS;
3159
3160 if (colors > 16) {
3161 /* Accent Colors */
3162 init_pair( ARGUS_RED, 160, ArgusBackGround); // red on kinda black
3163 init_pair( ARGUS_GREEN, 64, ArgusBackGround); // light green on kinda black
3164 init_pair( ARGUS_YELLOW, 136, ArgusBackGround); // light green on kinda black
3165 init_pair( ARGUS_BLUE, 33, ArgusBackGround); // light blue on kinda black
3166 init_pair( ARGUS_MAGENTA, 125, ArgusBackGround); // light blue on kinda black
3167 init_pair( ARGUS_CYAN, 37, ArgusBackGround); // light cyan on kinda black
3168 init_pair( ARGUS_ORANGE, 166, ArgusBackGround); // orange on kinda black
3169 init_pair( ARGUS_VIOLET, 61, ArgusBackGround); // light green on kinda black
3170
3171 if (ArgusBackGround == ARGUS_DARK) {
3172 init_pair(ARGUS_WHITE, 15, ArgusBackGround); // white on kinda black
3173
3174 /* Monotone Colors */
3175 init_pair( ARGUS_BASE3, 230, ArgusBackGround); //
3176 init_pair( ARGUS_BASE2, 254, ArgusBackGround); //
3177 init_pair( ARGUS_BASE1, 245, ArgusBackGround); //
3178 init_pair( ARGUS_BASE0, 244, ArgusBackGround); //
3179 init_pair( ARGUS_BASE00, 241, ArgusBackGround); //
3180 init_pair( ARGUS_BASE01, 240, ArgusBackGround); //
3181 init_pair( ARGUS_BASE02, 235, ArgusBackGround); //
3182 init_pair( ARGUS_BASE03, 234, ArgusBackGround); //
3183
3184 } else {
3185 init_pair(ARGUS_WHITE, 235, ArgusBackGround); // white on kinda black
3186
3187 init_pair( ARGUS_BASE3, 234, ArgusBackGround); // light gray on kinda black
3188 init_pair( ARGUS_BASE2, 235, ArgusBackGround); // light gray on kinda black
3189 init_pair( ARGUS_BASE1, 240, ArgusBackGround); // light gray on kinda black
3190 init_pair( ARGUS_BASE0, 241, ArgusBackGround); // light gray on kinda black
3191 init_pair( ARGUS_BASE00, 244, ArgusBackGround); // light gray on kinda black
3192 init_pair( ARGUS_BASE01, 245, ArgusBackGround); // light gray on kinda black
3193 init_pair( ARGUS_BASE02, 254, ArgusBackGround); // light gray on kinda black
3194 init_pair( ARGUS_BASE03, 230, ArgusBackGround); // light gray on kinda black
3195 }
3196
3197 } else {
3198 if (colors > 8) {
3199 init_pair( ARGUS_RED, 88, ArgusBackGround); // red on kinda white
3200 init_pair( ARGUS_WHITE, 15, ArgusBackGround); // white on kinda white
3201 init_pair( ARGUS_BASE0, 248, ArgusBackGround); // gray on kinda white
3202 init_pair( ARGUS_ORANGE, 131, ArgusBackGround); // organe on kinda white
3203 init_pair( ARGUS_BLUE, 27, ArgusBackGround); // light blue on kinda white
3204
3205 } else {
3206 init_pair( ARGUS_RED, COLOR_RED, COLOR_BLACK); // red on kinda white
3207 init_pair( ARGUS_WHITE, COLOR_WHITE, COLOR_BLACK); // white on kinda white
3208 init_pair( ARGUS_BASE0, COLOR_WHITE, COLOR_BLACK); // gray on kinda white
3209 init_pair( ARGUS_ORANGE, COLOR_RED, COLOR_BLACK); // organe on kinda white
3210 init_pair( ARGUS_BLUE, COLOR_BLUE, COLOR_BLACK); // light blue on kinda white
3211 init_pair( ARGUS_GREEN, COLOR_GREEN, COLOR_BLACK); // light blue on kinda white
3212 init_pair( ARGUS_CYAN, COLOR_CYAN, COLOR_BLACK); // light blue on kinda white
3213 }
3214 }
3215
3216 if (ArgusParser->ArgusColorConfig) {
3217 if ((ArgusParser->ArgusColorLabeler = ArgusNewLabeler(ArgusParser, 0L)) != NULL)
3218 if (RaReadFlowLabels (ArgusParser, ArgusParser->ArgusColorLabeler, ArgusParser->ArgusColorConfig) != 0)
3219 ArgusLog (LOG_ERR, "ArgusNewLabeler: RaReadFlowLabels error");
3220 }
3221 }
3222 }
3223
3224 #endif
3225
3226 getmaxyx(stdscr, RaScreenLines, RaScreenColumns);
3227
3228 RaWindowLines = RaScreenLines - (RaHeaderWinSize + RaStatusWinSize + RaDebugWinSize);
3229 RaDisplayLines = RaWindowLines;
3230
3231 RaHeaderWindow = newwin (RaHeaderWinSize, RaScreenColumns, 0, 0);
3232 RaDebugWindow = newwin (RaDebugWinSize, RaScreenColumns, RaScreenLines - 2, 0);
3233 RaStatusWindow = newwin (RaStatusWinSize, RaScreenColumns, RaScreenLines - 1, 0);
3234 RaDisplayWindow = newwin (RaDisplayLines, RaScreenColumns, RaHeaderWinSize, 0);
3235
3236 #if defined(ARGUS_COLOR_SUPPORT)
3237 if (ArgusTerminalColors) {
3238 wbkgd(RaHeaderWindow, COLOR_PAIR(ARGUS_WHITE));
3239 wbkgd(RaDebugWindow, COLOR_PAIR(ARGUS_WHITE));
3240 wbkgd(RaStatusWindow, COLOR_PAIR(ARGUS_WHITE));
3241 wbkgd(RaDisplayWindow, COLOR_PAIR(ARGUS_BASE0));
3242
3243 wattrset(RaHeaderWindow, COLOR_PAIR(ARGUS_WHITE));
3244 wattrset(RaStatusWindow, COLOR_PAIR(ARGUS_WHITE));
3245 wattrset(RaDebugWindow, COLOR_PAIR(ARGUS_WHITE));
3246 wattrset(RaDisplayWindow, COLOR_PAIR(ARGUS_BASE0));
3247
3248 wcolor_set(RaHeaderWindow, ARGUS_WHITE, NULL);
3249 wcolor_set(RaDebugWindow, ARGUS_WHITE, NULL);
3250 wcolor_set(RaStatusWindow, ARGUS_WHITE, NULL);
3251 wcolor_set(RaDisplayWindow, ARGUS_BASE0, NULL);
3252 refresh();
3253
3254 RaColorAlgorithms[0] = ArgusColorAvailability;
3255 RaColorAlgorithms[1] = ArgusColorAddresses;
3256 RaColorAlgorithms[2] = ArgusColorFlowFields;
3257 RaColorAlgorithms[3] = ArgusColorGeoLocation;
3258 }
3259
3260 #endif
3261
3262 intrflush(RaDisplayWindow, FALSE);
3263 curs_set(1);
3264
3265 #if defined(ARGUS_READLINE)
3266 #if defined(HAVE_DECL_RL_RESIZE_TERMINAL) && HAVE_DECL_RL_RESIZE_TERMINAL
3267 rl_resize_terminal();
3268 #endif
3269 #endif
3270
3271 ArgusColorHighlight = ARGUS_WHITE;
3272
3273 clearok(stdscr, TRUE);
3274 werase(stdscr);
3275 refresh();
3276 return (1);
3277 }
3278
3279
3280 void
ArgusTouchScreen(void)3281 ArgusTouchScreen(void)
3282 {
3283 RaWindowModified = RA_MODIFIED;
3284 RaWindowImmediate = TRUE;
3285 }
3286
3287 void
ArgusUpdateScreen(void)3288 ArgusUpdateScreen(void)
3289 {
3290 struct ArgusQueueStruct *queue;
3291
3292 ArgusTouchScreen();
3293
3294 if ((queue = RaCursesProcess->queue) != NULL) {
3295 int i;
3296
3297 #if defined(ARGUS_THREADS)
3298 pthread_mutex_lock(&queue->lock);
3299 #endif
3300 if (ArgusParser->ns)
3301 ArgusParser->ns->status |= ARGUS_RECORD_MODIFIED;
3302
3303 if (queue->array) {
3304 for (i = 0; i < queue->count; i++) {
3305 struct ArgusRecordStruct *ns;
3306 if ((ns = (struct ArgusRecordStruct *)queue->array[i]) == NULL)
3307 break;
3308 ns->status |= ARGUS_RECORD_MODIFIED;
3309 }
3310 }
3311
3312 queue->status |= RA_MODIFIED;
3313
3314 #if defined(ARGUS_THREADS)
3315 pthread_mutex_unlock(&queue->lock);
3316 #endif
3317 }
3318 }
3319 #endif
3320
3321
3322 void ArgusWindowClose(void);
3323
3324 void
ArgusWindowClose(void)3325 ArgusWindowClose(void)
3326 {
3327 if (!(ArgusWindowClosing++)) {
3328 #if defined(ARGUS_CURSES)
3329 struct timeval tvbuf, *tvp = &tvbuf;
3330 fd_set in;
3331 int ch;
3332
3333 if (RaCursesInit && (!(isendwin()))) {
3334 tvp->tv_sec = 0; tvp->tv_usec = 0;
3335 FD_ZERO(&in); FD_SET(0, &in);
3336
3337 while (select(1, &in, 0, 0, tvp) > 0)
3338 if ((ch = wgetch(RaStatusWindow)) == ERR)
3339 break;
3340
3341 endwin();
3342 printf("\n");
3343 }
3344 #endif
3345 }
3346
3347 ArgusParser->RaCursesMode = 0;
3348 #if defined(ARGUSDEBUG)
3349 ArgusDebug (1, "ArgusWindowClose () returning\n");
3350 #endif
3351 }
3352
3353
3354 #if defined(ARGUS_CURSES) && (defined(ARGUS_READLINE) || defined(ARGUS_EDITLINE))
3355 int
argus_getch_function(FILE * file)3356 argus_getch_function(FILE *file)
3357 {
3358 int retn = wgetch(RaStatusWindow);
3359 if (retn != ERR) {
3360 return retn;
3361 } else
3362 return -1;
3363 }
3364
3365
3366 int
argus_readline_timeout(void)3367 argus_readline_timeout(void)
3368 {
3369 int retn = 0;
3370
3371 if (RaWindowModified == RA_MODIFIED) {
3372 switch (RaInputStatus) {
3373 case RAGETTINGh:
3374 break;
3375 default:
3376 argus_redisplay_function();
3377 break;
3378 }
3379
3380 RaWindowModified = 0;
3381 RaWindowImmediate = FALSE;
3382 }
3383 return (retn);
3384 }
3385
3386
3387 int ArgusReadlinePoint = 0;
3388 void
argus_redisplay_function()3389 argus_redisplay_function()
3390 {
3391 int offset = 0, plen, sw = RaScreenColumns - 1;
3392
3393 switch (RaInputStatus) {
3394 case RAGETTINGh: {
3395 RaWindowStatus = 1;
3396
3397 RaInputStatus = RAGOTslash;
3398 RaInputString = RANEWCOMMANDSTR;
3399 RaCommandInputStr[0] = '\0';
3400 RaWindowModified = RA_MODIFIED;
3401 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
3402 rl_done = 1;
3403 #endif
3404 break;
3405 }
3406
3407 case RAGETTINGcolon:
3408 RaInputStatus = argus_process_command (ArgusParser, RaInputStatus);
3409 break;
3410 }
3411
3412 #if defined(ARGUS_THREADS)
3413 pthread_mutex_lock(&RaCursesLock);
3414 #endif
3415
3416 sprintf (RaOutputBuffer, "%s", RaInputString);
3417 plen = strlen(RaOutputBuffer);
3418
3419 if ((rl_point + 1) > (sw - plen)) {
3420 offset = (rl_point + 1) - (sw - plen);
3421 RaOutputBuffer[plen - 1] = '<';
3422 sprintf (&RaOutputBuffer[plen], "%s", &rl_line_buffer[offset]);
3423 } else {
3424 sprintf (&RaOutputBuffer[plen], "%s", rl_line_buffer);
3425 }
3426
3427 if (strlen(RaOutputBuffer) > sw)
3428 RaOutputBuffer[sw] = '>';
3429
3430 #ifdef ARGUSDEBUG
3431 ArgusDebug (4, "argus_redisplay_function: sw %d plen %d rl_point %d offset %d", sw, plen, rl_point, offset);
3432 #endif
3433
3434 mvwaddnstr (RaStatusWindow, 0, 0, RaOutputBuffer, sw + 1);
3435 wclrtoeol(RaStatusWindow);
3436
3437 if (offset > 0)
3438 wmove(RaStatusWindow, 0, plen + (rl_point - offset));
3439 else
3440 wmove(RaStatusWindow, 0, plen + rl_point);
3441
3442 touchwin(RaStatusWindow);
3443 wrefresh(RaStatusWindow);
3444
3445 #if defined(ARGUS_THREADS)
3446 pthread_mutex_unlock(&RaCursesLock);
3447 #endif
3448 }
3449
3450
3451 void
argus_getsearch_string(int dir)3452 argus_getsearch_string(int dir)
3453 {
3454 char *line;
3455
3456 #if defined(ARGUS_HISTORY)
3457 if (!(argus_history_is_enabled()))
3458 argus_enable_history();
3459 #endif
3460
3461 ArgusSearchDirection = dir;
3462
3463 RaInputStatus = RAGETTINGslash;
3464 RaInputString = (dir == ARGUS_FORWARD) ? "/" : "?";
3465 ArgusSearchDirection = dir;
3466 bzero(RaCommandInputStr, MAXSTRLEN);
3467 RaCommandIndex = 0;
3468
3469 ArgusReadlinePoint = 0;
3470
3471 if ((line = readline("")) != NULL) {
3472 int linenum = RaWindowCursorY;
3473 int cursx = RaWindowCursorX, cursy = RaWindowCursorY + RaWindowStartLine;
3474
3475 if (strlen(line) > 0) {
3476 strcpy (RaCommandInputStr, line);
3477 #if defined(ARGUS_HISTORY)
3478 if (*line && argus_history_is_enabled()) {
3479 add_history (line);
3480 }
3481 #endif
3482 free(line);
3483 sprintf(RaLastSearch, "%s", RaCommandInputStr);
3484 } else {
3485 if (strlen(RaLastSearch) > 0)
3486 sprintf(RaCommandInputStr, "%s", RaLastSearch);
3487 else {
3488 if (ArgusParser->ArgusSearchString != NULL) {
3489 free(ArgusParser->ArgusSearchString);
3490 ArgusParser->ArgusSearchString = NULL;
3491 }
3492 }
3493 }
3494
3495 ArgusParser->ArgusSearchString = strdup(RaCommandInputStr);
3496
3497 if ((linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, ArgusParser->ArgusSearchString, ARGUS_LOCK)) < 0) {
3498 if (ArgusSearchDirection == ARGUS_FORWARD) {
3499 ArgusSetDebugString ("search hit BOTTOM, continuing at TOP", LOG_ERR, ARGUS_LOCK);
3500 cursx = 0; cursy = 0;
3501 } else {
3502 ArgusSetDebugString ("search hit TOP, continuing at BOTTOM", LOG_ERR, ARGUS_LOCK);
3503 cursx = RaScreenColumns; cursy = RaSortItems;
3504 }
3505 linenum = RaSearchDisplay(ArgusParser, RaCursesProcess->queue, ArgusSearchDirection, &cursx, &cursy, ArgusParser->ArgusSearchString, ARGUS_LOCK);
3506 }
3507
3508 if (linenum >= 0) {
3509 if ((linenum < RaWindowStartLine) || ((linenum > RaWindowStartLine + RaDisplayLines))) {
3510 int startline = ((cursy - 1)/ RaDisplayLines) * RaDisplayLines;
3511 startline = (RaSortItems > startline) ? startline : RaSortItems - RaDisplayLines;
3512 startline = (startline > 0) ? startline : 0;
3513 RaWindowStartLine = startline;
3514
3515 if ((RaWindowCursorY = cursy % RaDisplayLines) == 0)
3516 RaWindowCursorY = RaDisplayLines;
3517
3518 } else
3519 RaWindowCursorY = cursy - RaWindowStartLine;
3520
3521 RaWindowCursorX = cursx;
3522
3523 } else {
3524 char sbuf[1024];
3525 sprintf (sbuf, "Pattern not found: %s", ArgusParser->ArgusSearchString);
3526 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
3527 RaInputString = RANEWCOMMANDSTR;
3528 bzero(RaCommandInputStr, MAXSTRLEN);
3529 RaCommandIndex = 0;
3530 }
3531
3532 RaInputStatus = RAGOTslash;
3533 RaInputString = (dir == ARGUS_FORWARD) ? "/" : "?";
3534
3535 } else {
3536 if (ArgusParser->ArgusSearchString != NULL) {
3537 free(ArgusParser->ArgusSearchString);
3538 ArgusParser->ArgusSearchString = NULL;
3539 }
3540 }
3541
3542 cbreak();
3543 RaCursesSetWindowFocus(ArgusParser, RaCurrentWindow->window);
3544 ArgusTouchScreen();
3545 }
3546
3547
3548 void
argus_command_string(void)3549 argus_command_string(void)
3550 {
3551 char *line, *sbuf = NULL;
3552
3553 if ((sbuf = (char *)ArgusMalloc(MAXSTRLEN)) == NULL)
3554 ArgusLog (LOG_ERR, "RaSQLProcessQueue: ArgusMalloc error %s", strerror(errno));
3555
3556 #if defined(ARGUS_HISTORY)
3557 argus_disable_history();
3558 #endif
3559
3560 RaInputStatus = RAGETTINGcolon;
3561 RaInputString = ":";
3562 bzero(RaCommandInputStr, MAXSTRLEN);
3563 RaCommandIndex = 0;
3564
3565 ArgusReadlinePoint = 0;
3566
3567 if ((line = readline("")) != NULL) {
3568 if (strlen(line) > 0) {
3569 strcpy (RaCommandInputStr, line);
3570 free(line);
3571 sprintf(RaLastCommand, "%s", RaCommandInputStr);
3572 } else {
3573 if (strlen(RaLastCommand) > 0)
3574 sprintf(RaCommandInputStr, "%s", RaLastCommand);
3575 }
3576 }
3577
3578 if (*RaCommandInputStr == 'q') {
3579 bzero (RaCommandInputStr, MAXSTRLEN);
3580 ArgusTouchScreen();
3581 RaParseComplete(SIGINT);
3582 }
3583
3584 if (strlen(RaCommandInputStr)) {
3585 switch(RaInputStatus) {
3586 case RAGETTINGh: {
3587 RaWindowStatus = 1;
3588 RaInputStatus = RAGOTcolon;
3589 wclear(RaCurrentWindow->window);
3590 ArgusTouchScreen();
3591 RaRefreshDisplay();
3592 break;
3593 }
3594
3595 case RAGETTINGN: {
3596 char *ptr = NULL;
3597 int value = strtol(RaCommandInputStr, (char **)&ptr, 10);
3598
3599 RaDisplayLinesSet = 1;
3600
3601 if (ptr != RaCommandInputStr) {
3602 int len = (RaScreenLines - (RaHeaderWinSize + 1));
3603 RaDisplayLines = ((value < len) ? value : len) + 1;
3604 ArgusTouchScreen();
3605
3606 } else
3607 RaDisplayLinesSet = 0;
3608
3609 wclear(RaCurrentWindow->window);
3610 break;
3611 }
3612
3613 case RAGETTINGS: {
3614 if (!(ArgusAddHostList (ArgusParser, RaCommandInputStr, (ArgusParser->Cflag ? ARGUS_CISCO_DATA_SOURCE : ARGUS_DATA_SOURCE), 0))) {
3615 ArgusLog (LOG_ALERT, "%s%s host not found", RaInputString, RaCommandInputStr);
3616 } else {
3617 ArgusParser->Sflag = 1;
3618 ArgusParser->RaParseDone = 0;
3619 }
3620 break;
3621 }
3622
3623 case RAGETTINGa: {
3624 if (!(strncasecmp(RaCommandInputStr, "Totals", 6))) {
3625 RaScreenResize = TRUE;
3626 if (ArgusPrintTotals == 0) {
3627 ArgusPrintTotals = 1;
3628 RaHeaderWinSize++;
3629 RaScreenMove = TRUE;
3630 }
3631 ArgusTouchScreen();
3632 }
3633 if (!(strncasecmp(RaCommandInputStr, "-Totals", 6))) {
3634 RaScreenResize = TRUE;
3635 if (ArgusPrintTotals > 0) {
3636 ArgusPrintTotals = 0;
3637 RaHeaderWinSize--;
3638 RaScreenMove = FALSE;
3639 getbegyx(RaCurrentWindow->window, RaScreenStartY, RaScreenStartX);
3640 if (mvwin(RaCurrentWindow->window, RaScreenStartY - 1, RaScreenStartX) == ERR)
3641 ArgusLog (LOG_ERR, "RaResizeScreen: mvwin %d, %d returned ERR\n", RaScreenStartY - 1, RaScreenStartX);
3642 }
3643 ArgusTouchScreen();
3644 }
3645 }
3646 break;
3647
3648 case RAGETTINGd: {
3649 struct ArgusInput *input;
3650 char strbuf[MAXSTRLEN];
3651
3652 if ((input = (void *)ArgusParser->ArgusActiveHosts->start) != NULL) {
3653 do {
3654 sprintf (strbuf, "%s:%d", input->hostname, input->portnum);
3655 if ((strstr (RaCommandInputStr, strbuf))) {
3656 ArgusRemoveFromQueue (ArgusParser->ArgusActiveHosts, &input->qhdr, ARGUS_LOCK);
3657 ArgusCloseInput(ArgusParser, input);
3658 break;
3659 }
3660 input = (void *)input->qhdr.nxt;
3661 } while (input != (void *)ArgusParser->ArgusActiveHosts->start);
3662 }
3663 }
3664 break;
3665
3666 case RAGETTINGD: {
3667 char *ptr = NULL;
3668 int value = strtol(RaCommandInputStr, (char **)&ptr, 10);
3669
3670 if (ptr != RaCommandInputStr)
3671 ArgusParser->debugflag = value;
3672 break;
3673 }
3674
3675 case RAGETTINGc: {
3676 break;
3677 }
3678
3679 case RAGETTINGe: {
3680 char *ptr = NULL;
3681
3682 ptr = RaCommandInputStr;
3683 while (isspace((int)*ptr)) ptr++;
3684
3685 ArgusParser->ArgusGrepSource = 1;
3686 ArgusParser->ArgusGrepDestination = 1;
3687
3688 if (ArgusParser->estr != NULL)
3689 free(ArgusParser->estr);
3690 ArgusParser->estr = strdup(RaCommandInputStr);
3691
3692 if ((ArgusParser->estr[0] == 's') && (ArgusParser->estr[1] == ':')) {
3693 ArgusParser->ArgusGrepDestination = 0;
3694 ArgusParser->estr = &ArgusParser->estr[2];
3695 }
3696 if ((ArgusParser->estr[0] == 'd') && (ArgusParser->estr[1] == ':')) {
3697 ArgusParser->ArgusGrepSource = 0;
3698 ArgusParser->estr = &ArgusParser->estr[2];
3699 }
3700
3701 break;
3702 }
3703
3704 case RAGETTINGf: {
3705 struct nff_program lfilter;
3706 char *ptr = NULL, *str = NULL;
3707 int ind = ARGUS_REMOTE_FILTER;
3708 int i, retn;
3709
3710 bzero ((char *) &lfilter, sizeof (lfilter));
3711 ptr = RaCommandInputStr;
3712 while (isspace((int)*ptr)) ptr++;
3713
3714 if ((str = strstr (ptr, "local")) != NULL) {
3715 ptr = strdup(&str[strlen("local ")]);
3716 ind = ARGUS_LOCAL_FILTER;
3717 } else
3718 if ((str = strstr (ptr, "display")) != NULL) {
3719 ptr = strdup(&str[strlen("display ")]);
3720 ind = ARGUS_DISPLAY_FILTER;
3721 } else
3722 if ((str = strstr (ptr, "remote")) != NULL) {
3723 ptr = strdup(&str[strlen("remote ")]);
3724 ind = ARGUS_REMOTE_FILTER;
3725 } else
3726 if ((str = strstr (ptr, "none")) != NULL) {
3727 ind = RaFilterIndex;
3728 }
3729
3730 if ((retn = ArgusFilterCompile (&lfilter, ptr, 1)) < 0) {
3731 sprintf (sbuf, "%s%s syntax error", RAGETTINGfSTR, RaCommandInputStr);
3732 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
3733
3734 } else {
3735 sprintf (sbuf, "%s%s filter accepted", RAGETTINGfSTR, RaCommandInputStr);
3736 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
3737 if ((str = ptr) != NULL)
3738 while (isspace((int)*str)) str++;
3739
3740 switch (ind) {
3741 case ARGUS_LOCAL_FILTER:
3742 if (ArgusParser->ArgusFilterCode.bf_insns != NULL)
3743 free (ArgusParser->ArgusFilterCode.bf_insns);
3744
3745 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusFilterCode, sizeof(lfilter));
3746 if (ArgusParser->ArgusLocalFilter != NULL) {
3747 free(ArgusParser->ArgusLocalFilter);
3748 ArgusParser->ArgusLocalFilter = NULL;
3749 }
3750 if (strlen(str) > 0)
3751 ArgusParser->ArgusLocalFilter = ptr;
3752 else
3753 if (ptr != NULL) free(ptr);
3754 break;
3755
3756 case ARGUS_DISPLAY_FILTER:
3757 if (ArgusParser->ArgusDisplayCode.bf_insns != NULL)
3758 free (ArgusParser->ArgusDisplayCode.bf_insns);
3759
3760 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusDisplayCode, sizeof(lfilter));
3761 bcopy((char *)&lfilter, (char *)&ArgusSorter->filter, sizeof(lfilter));
3762
3763 if (ArgusParser->ArgusDisplayFilter != NULL) {
3764 free(ArgusParser->ArgusDisplayFilter);
3765 ArgusParser->ArgusDisplayFilter = NULL;
3766 }
3767 if (strlen(str) > 0)
3768 ArgusParser->ArgusDisplayFilter = ptr;
3769 else
3770 if (ptr != NULL) free(ptr);
3771 break;
3772
3773 case ARGUS_REMOTE_FILTER:
3774 if (ArgusParser->ArgusFilterCode.bf_insns != NULL)
3775 free (ArgusParser->ArgusFilterCode.bf_insns);
3776 bcopy((char *)&lfilter, (char *)&ArgusParser->ArgusFilterCode, sizeof(lfilter));
3777 if (ArgusParser->ArgusRemoteFilter != NULL) {
3778 free(ArgusParser->ArgusRemoteFilter);
3779 ArgusParser->ArgusRemoteFilter = NULL;
3780 }
3781 if (strlen(str) > 0)
3782 ArgusParser->ArgusRemoteFilter = ptr;
3783 else
3784 if (ptr != NULL) free(ptr);
3785 break;
3786 }
3787
3788 #if defined(ARGUS_THREADS)
3789 pthread_mutex_lock(&RaCursesProcess->queue->lock);
3790 #endif
3791 RaClientSortQueue(ArgusSorter, RaCursesProcess->queue, ARGUS_NOLOCK);
3792
3793 if (RaSortItems) {
3794 if (ArgusParser->ns) {
3795 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
3796 ArgusParser->ns = NULL;
3797 }
3798 for (i = 0; i < RaSortItems; i++) {
3799 struct ArgusRecordStruct *ns;
3800 if ((ns = (struct ArgusRecordStruct *)RaCursesProcess->queue->array[i]) == NULL)
3801 break;
3802 if (ArgusParser->ns)
3803 ArgusMergeRecords (ArgusParser->ArgusAggregator, ArgusParser->ns, ns);
3804 else
3805 ArgusParser->ns = ArgusCopyRecordStruct (ns);
3806 }
3807 }
3808 RaCursesProcess->queue->status |= RA_MODIFIED;
3809
3810 #if defined(ARGUS_THREADS)
3811 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
3812 #endif
3813 RaWindowStatus = 1;
3814 ArgusTouchScreen();
3815 RaRefreshDisplay();
3816 }
3817 break;
3818 }
3819
3820 case RAGETTINGm: {
3821 struct ArgusRecordStruct *ns = NULL;
3822 char strbuf[MAXSTRLEN], *tok = NULL, *ptr;
3823 struct ArgusModeStruct *mode = NULL, *modelist = NULL, *list;
3824 struct ArgusAggregatorStruct *agg = ArgusParser->ArgusAggregator;
3825 int i;
3826
3827 if ((agg->modeStr == NULL) || strcmp(agg->modeStr, RaCommandInputStr)) {
3828 if (agg->modeStr != NULL)
3829 free(agg->modeStr);
3830 agg->modeStr = strdup(RaCommandInputStr);
3831 ArgusParser->RaMonMode = 0;
3832 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
3833
3834 if ((mode = ArgusParser->ArgusMaskList) != NULL)
3835 ArgusDeleteMaskList(ArgusParser);
3836
3837 agg->mask = 0;
3838 agg->saddrlen = 0;
3839 agg->daddrlen = 0;
3840
3841 if ((ptr = strbuf) != NULL) {
3842 while ((tok = strtok (ptr, " \t")) != NULL) {
3843 if ((mode = (struct ArgusModeStruct *) ArgusCalloc (1, sizeof(struct ArgusModeStruct))) != NULL) {
3844 if ((list = modelist) != NULL) {
3845 while (list->nxt)
3846 list = list->nxt;
3847 list->nxt = mode;
3848 } else
3849 modelist = mode;
3850 mode->mode = strdup(tok);
3851 }
3852 ptr = NULL;
3853 }
3854 } else {
3855 if ((modelist = ArgusParser->ArgusMaskList) == NULL)
3856 agg->mask = ( ARGUS_MASK_SRCID_INDEX | ARGUS_MASK_PROTO_INDEX |
3857 ARGUS_MASK_SADDR_INDEX | ARGUS_MASK_SPORT_INDEX |
3858 ARGUS_MASK_DADDR_INDEX | ARGUS_MASK_DPORT_INDEX );
3859 }
3860
3861 ArgusInitAggregatorStructs(agg);
3862
3863 if ((mode = modelist) != NULL) {
3864 while (mode) {
3865 char *ptr = NULL, **endptr = NULL;
3866 int value = 0;
3867
3868 if ((ptr = strchr(mode->mode, '/')) != NULL) {
3869 ptr++;
3870 if ((value = strtol(ptr, endptr, 10)) == 0)
3871 if (*endptr == ptr)
3872 usage();
3873 }
3874 if (!(strncasecmp (mode->mode, "none", 4))) {
3875 agg->mask = 0;
3876 } else
3877 if (!(strncasecmp (mode->mode, "mac", 3))) {
3878 ArgusParser->RaMonMode++;
3879 agg->mask |= (0x01LL << ARGUS_MASK_SMAC);
3880 if (value > 0) {
3881 agg->saddrlen = value;
3882 agg->daddrlen = value;
3883 }
3884 } else
3885 if (!(strncasecmp (mode->mode, "addr", 4))) {
3886 ArgusParser->RaMonMode++;
3887 agg->mask |= (0x01LL << ARGUS_MASK_SADDR);
3888 if (value > 0) {
3889 agg->saddrlen = value;
3890 agg->daddrlen = value;
3891 }
3892 } else
3893 if (!(strncasecmp (mode->mode, "matrix", 6))) {
3894 agg->ArgusMatrixMode++;
3895 agg->mask |= (0x01LL << ARGUS_MASK_SADDR);
3896 agg->mask |= (0x01LL << ARGUS_MASK_DADDR);
3897 if (value > 0) {
3898 agg->saddrlen = value;
3899 agg->daddrlen = value;
3900 }
3901 } else {
3902 struct ArgusMaskStruct *ArgusMaskDefs = ArgusIpV4MaskDefs;
3903
3904 for (i = 0; i < ARGUS_MAX_MASK_LIST; i++) {
3905 if (!(strncasecmp (mode->mode, ArgusMaskDefs[i].name, ArgusMaskDefs[i].slen))) {
3906 agg->mask |= (0x01LL << i);
3907 switch (i) {
3908 case ARGUS_MASK_SADDR:
3909 if (value > 0) {
3910 agg->saddrlen = value;
3911 if (value <= 32)
3912 agg->smask.addr_un.ipv4 = (0xFFFFFFFF << (32 - value));
3913 }
3914 break;
3915 case ARGUS_MASK_DADDR:
3916 if (value > 0) {
3917 agg->daddrlen = value;
3918 if (value <= 32)
3919 agg->dmask.addr_un.ipv4 = (0xFFFFFFFF << (32 - value));
3920 }
3921 break;
3922
3923 case ARGUS_MASK_SMPLS:
3924 case ARGUS_MASK_DMPLS: {
3925 int x, RaNewIndex = 0;
3926 char *ptr;
3927
3928 if ((ptr = strchr(mode->mode, '[')) != NULL) {
3929 char *cptr = NULL;
3930 int sind = -1, dind = -1;
3931 *ptr++ = '\0';
3932 while (*ptr != ']') {
3933 if (isdigit((int)*ptr)) {
3934 dind = strtol(ptr, (char **)&cptr, 10);
3935 if (cptr == ptr)
3936 usage ();
3937
3938 if (sind < 0)
3939 sind = dind;
3940
3941 for (x = sind; x <= dind; x++)
3942 RaNewIndex |= 0x01 << x;
3943
3944 ptr = cptr;
3945 if (*ptr != ']')
3946 ptr++;
3947 if (*cptr != '-')
3948 sind = -1;
3949 } else
3950 usage ();
3951 }
3952 ArgusIpV4MaskDefs[i].index = RaNewIndex;
3953 ArgusIpV6MaskDefs[i].index = RaNewIndex;
3954 ArgusEtherMaskDefs[i].index = RaNewIndex;
3955 }
3956 break;
3957 }
3958 }
3959 break;
3960 }
3961 }
3962 }
3963 mode = mode->nxt;
3964 }
3965 }
3966
3967 ArgusParser->ArgusMaskList = modelist;
3968
3969 #if defined(ARGUS_THREADS)
3970 pthread_mutex_lock(&RaCursesProcess->queue->lock);
3971 #endif
3972 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(RaCursesProcess->queue, ARGUS_NOLOCK)) != NULL) {
3973 if (ArgusSearchHitRecord == ns) {
3974 ArgusResetSearch();
3975 }
3976 ArgusDeleteRecordStruct (ArgusParser, ns);
3977 }
3978
3979 ArgusEmptyHashTable(RaCursesProcess->htable);
3980
3981 if (ArgusParser->ns != NULL) {
3982 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
3983 ArgusParser->ns = NULL;
3984 }
3985
3986 ArgusParser->RaClientUpdate.tv_sec = 0;
3987 #if defined(ARGUS_THREADS)
3988 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
3989 #endif
3990 werase(RaCurrentWindow->window);
3991 ArgusTouchScreen();
3992 }
3993
3994 break;
3995 }
3996
3997 case RAGETTINGM: {
3998 char strbuf[MAXSTRLEN], *str = strbuf, *tok = NULL;
3999 struct ArgusModeStruct *mode = NULL;
4000 char *tzptr;
4001 int retn = 0;
4002
4003 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
4004
4005 if ((tzptr = strstr(strbuf, "TZ=")) != NULL) {
4006 if (ArgusParser->RaTimeZone)
4007 free (ArgusParser->RaTimeZone);
4008 ArgusParser->RaTimeZone = strdup(tzptr);
4009 tzptr = getenv("TZ");
4010 #if defined(HAVE_SETENV) && HAVE_SETENV
4011 if ((retn = setenv("TZ", (ArgusParser->RaTimeZone + 3), 1)) < 0) {
4012 sprintf (sbuf, "setenv(TZ, %s, 1) error %s", ArgusParser->RaTimeZone + 3, strerror(errno));
4013 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4014 }
4015 #else
4016 if ((retn = putenv(ArgusParser->RaTimeZone)) < 0) {
4017 sprintf (sbuf, "setenv(TZ, %s, 1) error %s", ArgusParser->RaTimeZone + 3, strerror(errno));
4018 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4019 }
4020 #endif
4021 if (retn == 0) {
4022 tzset();
4023 sprintf (sbuf, "Timezone changed from %s to %s", tzptr, getenv("TZ"));
4024 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
4025 }
4026
4027 ArgusTouchScreen();
4028 break;
4029 }
4030
4031 if ((mode = ArgusParser->ArgusModeList) != NULL) {
4032 ArgusDeleteModeList(ArgusParser);
4033 ArgusParser->RaCumulativeMerge = 1;
4034 }
4035
4036 if (strlen(strbuf) > 0) {
4037 while ((tok = strtok(str, " \t\n")) != NULL) {
4038 if (!(strncasecmp (tok, "none", 4)))
4039 ArgusDeleteModeList(ArgusParser);
4040 else if (!(strncasecmp (tok, "default", 7))) {
4041 ArgusDeleteModeList(ArgusParser);
4042 } else
4043 ArgusAddModeList (ArgusParser, tok);
4044 str = NULL;
4045 }
4046 }
4047
4048 if ((mode = ArgusParser->ArgusModeList) != NULL) {
4049 struct RaBinProcessStruct *RaBinProcess = ArgusParser->RaBinProcess;
4050 struct ArgusAdjustStruct *nadp = NULL;
4051 int i, ind;
4052
4053 while (mode) {
4054 for (i = 0, ind = -1; i < ARGUSSPLITMODENUM; i++) {
4055 if (!(strncasecmp (mode->mode, RaSplitModes[i], strlen(RaSplitModes[i])))) {
4056 ind = i;
4057 break;
4058 }
4059 }
4060
4061 if (ind >= 0) {
4062 char *mptr = NULL;
4063 int size = -1;
4064 nadp = &RaBinProcess->nadp;
4065
4066 nadp = &RaBinProcess->nadp;
4067
4068 switch (ind) {
4069 case ARGUSSPLITRATE: { /* "%d:%d[yMwdhms]" */
4070 struct ArgusModeStruct *tmode = NULL;
4071 nadp->mode = ind;
4072 if ((tmode = mode->nxt) != NULL) {
4073 mptr = tmode->mode;
4074 if (isdigit((int)*tmode->mode)) {
4075 char *ptr = NULL;
4076 nadp->len = strtol(tmode->mode, (char **)&ptr, 10);
4077 if (*ptr++ != ':')
4078 usage();
4079 tmode->mode = ptr;
4080 }
4081 }
4082 }
4083
4084 case ARGUSSPLITTIME: /* "%d[yMwdhms] */
4085 nadp->mode = ind;
4086 if ((mode = mode->nxt) != NULL) {
4087 if (isdigit((int)*mode->mode)) {
4088 char *ptr = NULL;
4089 nadp->value = strtol(mode->mode, (char **)&ptr, 10);
4090 if (ptr == mode->mode)
4091 usage();
4092 else {
4093 switch (*ptr) {
4094 case 'y':
4095 nadp->qual = ARGUSSPLITYEAR;
4096 size = nadp->value * 31556926;
4097 break;
4098 case 'M':
4099 nadp->qual = ARGUSSPLITMONTH;
4100 size = nadp->value * 2629744;
4101 break;
4102 case 'w':
4103 nadp->qual = ARGUSSPLITWEEK;
4104 size = nadp->value * 604800;
4105 break;
4106 case 'd':
4107 nadp->qual = ARGUSSPLITDAY;
4108 size = nadp->value * 86400;
4109 break;
4110 case 'h':
4111 nadp->qual = ARGUSSPLITHOUR;
4112 size = nadp->value * 3600;
4113 break;
4114 case 'm':
4115 nadp->qual = ARGUSSPLITMINUTE;
4116 size = nadp->value * 60;
4117 break;
4118 default:
4119 nadp->qual = ARGUSSPLITSECOND;
4120 size = nadp->value;
4121 break;
4122 }
4123 }
4124 }
4125 if (mptr != NULL)
4126 mode->mode = mptr;
4127 }
4128
4129 nadp->modify = 1;
4130
4131 if (ind == ARGUSSPLITRATE) {
4132 /* need to set the flow idle timeout value to be equal to or
4133 just a bit bigger than (nadp->len * size) */
4134
4135 ArgusParser->timeout.tv_sec = (nadp->len * size);
4136 ArgusParser->timeout.tv_usec = 0;
4137 }
4138
4139 ArgusSorter->ArgusSortAlgorithms[0] = ArgusSortStartTime;
4140 ArgusSorter->ArgusSortAlgorithms[1] = NULL;
4141 break;
4142
4143 case ARGUSSPLITSIZE:
4144 case ARGUSSPLITCOUNT:
4145 nadp->mode = ind;
4146 nadp->count = 1;
4147
4148 if ((mode = mode->nxt) != NULL) {
4149 if (isdigit((int)*mode->mode)) {
4150 char *ptr = NULL;
4151 nadp->value = strtol(mode->mode, (char **)&ptr, 10);
4152 if (ptr == mode->mode)
4153 usage();
4154 else {
4155 switch (*ptr) {
4156 case 'B':
4157 case 'b': nadp->value *= 1000000000; break;
4158
4159 case 'M':
4160 case 'm': nadp->value *= 1000000; break;
4161
4162 case 'K':
4163 case 'k': nadp->value *= 1000; break;
4164 }
4165 }
4166 }
4167 }
4168 ArgusSorter->ArgusSortAlgorithms[0] = NULL;
4169 break;
4170
4171 case ARGUSSPLITNOMODIFY:
4172 nadp->modify = 0;
4173 break;
4174
4175 case ARGUSSPLITHARD:
4176 nadp->hard++;
4177 break;
4178
4179 case ARGUSSPLITZERO:
4180 nadp->zero++;
4181 break;
4182 }
4183
4184 } else {
4185 if (!(strncasecmp (mode->mode, "nomerge", 7))) {
4186 ArgusParser->RaCumulativeMerge = 0;
4187 } else
4188 if (!(strncasecmp (mode->mode, "merge", 5))) {
4189 ArgusParser->RaCumulativeMerge = 1;
4190 }
4191 }
4192
4193 mode = mode->nxt;
4194 }
4195 }
4196
4197 break;
4198 }
4199
4200 case RAGETTINGn: {
4201 char *name = NULL;;
4202
4203 if (strstr(RaCommandInputStr, "all")) ArgusParser->nflag = 0; else
4204 if (strstr(RaCommandInputStr, "port")) ArgusParser->nflag = 1; else
4205 if (strstr(RaCommandInputStr, "proto")) ArgusParser->nflag = 2; else
4206 if (strstr(RaCommandInputStr, "none")) ArgusParser->nflag = 3;
4207
4208 switch (ArgusParser->nflag) {
4209 case 0: name = "all"; break;
4210 case 1: name = "port"; break;
4211 case 2: name = "proto"; break;
4212 case 3: name = "none"; break;
4213 default: name = "port"; ArgusParser->nflag = 2; break;
4214 }
4215
4216 sprintf (sbuf, "%s changed to %s ", RAGETTINGnSTR, name);
4217 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
4218 ArgusProcessNewPage(RaCurrentWindow->window, 0, 0);
4219 break;
4220 }
4221
4222 case RAGETTINGp: {
4223 char *endptr = NULL;
4224 int value = 0;
4225
4226 value = strtod(RaCommandInputStr, &endptr);
4227
4228 if (RaCommandInputStr != endptr) {
4229 ArgusParser->pflag = value;
4230 sprintf (sbuf, "%s %s precision accepted", RAGETTINGpSTR, RaCommandInputStr);
4231 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
4232 } else {
4233 sprintf (sbuf, "%s %s syntax error", RAGETTINGuSTR, RaCommandInputStr);
4234 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4235 }
4236
4237 ArgusUpdateScreen();
4238 break;
4239 }
4240
4241 case RAGETTINGR: {
4242 char strbuf[MAXSTRLEN], *str = strbuf, *ptr = NULL;
4243 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
4244
4245 if (strlen(strbuf) > 0) {
4246 ArgusDeleteFileList(ArgusParser);
4247 while ((ptr = strtok(str, " ")) != NULL) {
4248 RaProcessRecursiveFiles (ptr);
4249 str = NULL;
4250 }
4251 }
4252 break;
4253 }
4254
4255 case RAGETTINGr: {
4256 char strbuf[MAXSTRLEN], *str = strbuf, *ptr = NULL;
4257 glob_t globbuf;
4258
4259 bzero (strbuf, MAXSTRLEN);
4260 strncpy(strbuf, RaCommandInputStr, MAXSTRLEN);
4261
4262 if (strlen(strbuf) > 0) {
4263 struct ArgusRecordStruct *ns = NULL;
4264
4265 ArgusDeleteFileList(ArgusParser);
4266 while ((ptr = strtok(str, " ")) != NULL) {
4267 glob (ptr, 0, NULL, &globbuf);
4268 if (globbuf.gl_pathc > 0) {
4269 int i;
4270 for (i = 0; i < globbuf.gl_pathc; i++)
4271 ArgusAddFileList (ArgusParser, globbuf.gl_pathv[i], ARGUS_DATA_SOURCE, -1, -1);
4272 } else {
4273 sprintf (sbuf, "%s no files found for %s", RAGETTINGrSTR, ptr);
4274 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4275 }
4276 str = NULL;
4277 }
4278 ArgusParser->RaTasksToDo = 1;
4279 ArgusParser->Sflag = 0;
4280
4281 #if defined(ARGUS_THREADS)
4282 pthread_mutex_lock(&RaCursesProcess->queue->lock);
4283 #endif
4284 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(RaCursesProcess->queue, ARGUS_NOLOCK)) != NULL) {
4285 if (ArgusSearchHitRecord == ns) {
4286 ArgusResetSearch();
4287 }
4288 ArgusDeleteRecordStruct (ArgusParser, ns);
4289 }
4290
4291 ArgusEmptyHashTable(RaCursesProcess->htable);
4292
4293 if (ArgusParser->ns != NULL) {
4294 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
4295 ArgusParser->ns = NULL;
4296 }
4297
4298 ArgusParser->RaClientUpdate.tv_sec = 0;
4299 ArgusParser->status &= ~ARGUS_FILE_LIST_PROCESSED;
4300 ArgusParser->ArgusLastTime.tv_sec = 0;
4301 ArgusParser->ArgusLastTime.tv_usec = 0;
4302 #if defined(ARGUS_THREADS)
4303 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
4304 #endif
4305 }
4306 break;
4307 }
4308
4309 case RAGETTINGs: {
4310 char strbuf[MAXSTRLEN], *ptr = strbuf, *tok;
4311 int (*srtalg[ARGUS_MAX_SORT_ALG])(struct ArgusRecordStruct *, struct ArgusRecordStruct *);
4312 int i, x, ind = 0;
4313 strncpy (strbuf, RaCommandInputStr, MAXSTRLEN);
4314 bzero(srtalg, sizeof(srtalg));
4315 while ((tok = strtok(ptr, " ")) != NULL) {
4316 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++) {
4317 if (!strncmp (ArgusSortKeyWords[x], tok, strlen(ArgusSortKeyWords[x]))) {
4318 srtalg[ind++] = ArgusSortAlgorithmTable[x];
4319 break;
4320 }
4321 }
4322 if (x == ARGUS_MAX_SORT_ALG) {
4323 bzero(srtalg, sizeof(srtalg));
4324 ArgusLog (LOG_ALERT, "sort keyword %s not valid", tok);
4325 break;
4326 }
4327 ptr = NULL;
4328 }
4329
4330 if (srtalg[0] != NULL) {
4331 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++)
4332 ArgusSorter->ArgusSortAlgorithms[x] = srtalg[x];
4333 }
4334
4335 #if defined(ARGUS_THREADS)
4336 pthread_mutex_lock(&RaCursesProcess->queue->lock);
4337 #endif
4338 RaClientSortQueue(ArgusSorter, RaCursesProcess->queue, ARGUS_NOLOCK);
4339
4340 if (ArgusParser->ns) {
4341 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
4342 ArgusParser->ns = NULL;
4343 }
4344
4345 for (i = 0; i < RaCursesProcess->queue->count; i++) {
4346 struct ArgusRecordStruct *ns;
4347 if ((ns = (struct ArgusRecordStruct *)RaCursesProcess->queue->array[i]) == NULL)
4348 break;
4349 if (ArgusParser->ns)
4350 ArgusMergeRecords (ArgusParser->ArgusAggregator, ArgusParser->ns, ns);
4351 else
4352 ArgusParser->ns = ArgusCopyRecordStruct (ns);
4353 }
4354 #if defined(ARGUS_THREADS)
4355 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
4356 #endif
4357 ArgusTouchScreen();
4358 break;
4359 }
4360
4361 case RAGETTINGT: {
4362 double sec, usec, value;
4363 char *ptr = NULL;
4364
4365 value = strtod(RaCommandInputStr, (char **)&ptr);
4366 if (ptr != RaCommandInputStr) {
4367 usec = modf(value, &sec);
4368 ArgusParser->timeout.tv_sec = sec;
4369 ArgusParser->timeout.tv_usec = usec;
4370 }
4371 break;
4372 }
4373
4374 case RAGETTINGt: {
4375 if (ArgusParser->timearg) {
4376 free (ArgusParser->timearg);
4377 ArgusParser->timearg = NULL;
4378 }
4379
4380 if (strlen(RaCommandInputStr))
4381 ArgusParser->timearg = strdup(RaCommandInputStr);
4382
4383 ArgusCheckTimeFormat (&ArgusParser->RaTmStruct, ArgusParser->timearg);
4384 break;
4385 }
4386
4387 case RAGETTINGu: {
4388 double value = 0.0, ivalue, fvalue;
4389 char *endptr = NULL;
4390
4391 value = strtod(RaCommandInputStr, &endptr);
4392
4393 if (RaCommandInputStr != endptr) {
4394 fvalue = modf(value, &ivalue);
4395
4396 RaCursesUpdateInterval.tv_sec = (int) ivalue;
4397 RaCursesUpdateInterval.tv_usec = (int) (fvalue * 1000000.0);
4398
4399 sprintf (sbuf, "%s %s interval accepted", RAGETTINGuSTR, RaCommandInputStr);
4400 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
4401 RaCursesUpdateTime = ArgusParser->ArgusRealTime;
4402
4403 } else {
4404 sprintf (sbuf, "%s %s syntax error", RAGETTINGuSTR, RaCommandInputStr);
4405 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4406 }
4407
4408 break;
4409 }
4410
4411
4412 case RAGETTINGU: {
4413 char *endptr = NULL;
4414 double value = 0.0;
4415
4416 value = strtod(RaCommandInputStr, &endptr);
4417
4418 if (RaCommandInputStr != endptr) {
4419 RaUpdateRate = value;
4420 sprintf (sbuf, "%s %s accepted", RAGETTINGUSTR, RaCommandInputStr);
4421 ArgusSetDebugString (sbuf, 0, ARGUS_LOCK);
4422
4423 } else {
4424 sprintf (sbuf, "%s %s syntax error", RAGETTINGUSTR, RaCommandInputStr);
4425 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
4426 }
4427
4428 break;
4429 }
4430
4431
4432 case RAGETTINGw: {
4433 struct ArgusListStruct *wlist = ArgusParser->ArgusWfileList;
4434 struct ArgusWfileStruct *wfile = NULL;
4435 struct ArgusRecord *argusrec = NULL;
4436 struct ArgusRecordStruct *ns;
4437 static char buf[0x10000];
4438 int i;
4439
4440 if (strlen(RaCommandInputStr)) {
4441 if (RaSortItems > 0) {
4442 ArgusParser->ArgusWfileList = NULL;
4443 setArgusWfile (ArgusParser, RaCommandInputStr, NULL);
4444 wfile = (struct ArgusWfileStruct *) ArgusParser->ArgusWfileList->start;
4445
4446 #if defined(ARGUS_THREADS)
4447 pthread_mutex_lock(&RaCursesProcess->queue->lock);
4448 #endif
4449 for (i = 0; i < RaSortItems; i++) {
4450 int pass = 1;
4451
4452 if ((ns = (struct ArgusRecordStruct *) RaCursesProcess->queue->array[i]) == NULL)
4453 break;
4454
4455 if (wfile->filterstr) {
4456 struct nff_insn *wfcode = wfile->filter.bf_insns;
4457 pass = ArgusFilterRecord (wfcode, ns);
4458 }
4459
4460 if (pass != 0) {
4461 if ((argusrec = ArgusGenerateRecord (ns, 0L, buf)) != NULL) {
4462 #ifdef _LITTLE_ENDIAN
4463 ArgusHtoN(argusrec);
4464 #endif
4465 ArgusWriteNewLogfile (ArgusParser, ns->input, wfile, argusrec);
4466
4467 }
4468 }
4469 }
4470 #if defined(ARGUS_THREADS)
4471 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
4472 #endif
4473 fflush(wfile->fd);
4474 fclose(wfile->fd);
4475 clearArgusWfile(ArgusParser);
4476 ArgusParser->ArgusWfileList = wlist;
4477 }
4478 }
4479
4480 break;
4481 }
4482
4483 case RAGETTINGF: {
4484 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
4485 char strbuf[MAXSTRLEN], *ptr = strbuf, *tok;
4486 int x;
4487
4488 strncpy (strbuf, RaCommandInputStr, MAXSTRLEN);
4489 bzero ((char *)ArgusParser->RaPrintOptionStrings, sizeof(ArgusParser->RaPrintOptionStrings));
4490 ArgusParser->RaPrintOptionIndex = 0;
4491 while ((tok = strtok(ptr, " ")) != NULL) {
4492 if (ArgusParser->RaPrintOptionIndex < ARGUS_MAX_S_OPTIONS)
4493 ArgusParser->RaPrintOptionStrings[ArgusParser->RaPrintOptionIndex++] = tok;
4494 ptr = NULL;
4495 }
4496
4497 if (ArgusParser->RaPrintOptionIndex > 0) {
4498 ArgusProcessSOptions(ArgusParser);
4499 for (x = 0; x < ArgusParser->RaPrintOptionIndex; x++)
4500 if (ArgusParser->RaPrintOptionStrings[x] != NULL)
4501 ArgusParser->RaPrintOptionStrings[x] = NULL;
4502 ArgusParser->RaPrintOptionIndex = 0;
4503 }
4504
4505 for (x = 0, ArgusAlwaysUpdate = 0; x < MAX_PRINT_ALG_TYPES; x++)
4506 if (ArgusParser->RaPrintAlgorithmList[x] != NULL)
4507 if (ArgusParser->RaPrintAlgorithmList[x]->print == ArgusPrintIdleTime)
4508 ArgusAlwaysUpdate++;
4509
4510 if (queue == RaCursesProcess->queue) {
4511 int i;
4512 if (ArgusParser->ns) {
4513 ArgusParser->ns->status |= ARGUS_RECORD_MODIFIED;
4514 }
4515 for (i = 0; i < queue->count; i++) {
4516 struct ArgusRecordStruct *ns;
4517 if ((ns = (struct ArgusRecordStruct *)queue->array[i]) == NULL)
4518 break;
4519 ns->status |= ARGUS_RECORD_MODIFIED;
4520 }
4521 }
4522 ArgusInitializeColorMap(ArgusParser, RaDisplayWindow);
4523 ArgusTouchScreen();
4524 break;
4525 }
4526
4527 case RAGETTINGcolon: {
4528 char *endptr = NULL;
4529 int linenum, startline;
4530
4531 linenum = (int)strtol(RaCommandInputStr, &endptr, 10);
4532 if (RaCommandInputStr == endptr) {
4533 switch (*RaCommandInputStr) {
4534 case 'q': {
4535 bzero (RaCommandInputStr, MAXSTRLEN);
4536 ArgusTouchScreen();
4537 RaParseComplete(SIGINT);
4538 break;
4539 }
4540 }
4541 } else {
4542 if ((linenum >= RaWindowStartLine) && (linenum <= (RaWindowStartLine + RaDisplayLines)))
4543 RaWindowCursorY = linenum - RaWindowStartLine;
4544 else {
4545 startline = ((linenum - 1)/ RaDisplayLines) * RaDisplayLines;
4546 startline = (RaSortItems > startline) ? startline : RaSortItems - RaDisplayLines;
4547 startline = (startline > 0) ? startline : 0;
4548 RaWindowStartLine = startline;
4549 if ((RaWindowCursorY = linenum % RaDisplayLines) == 0)
4550 RaWindowCursorY = RaDisplayLines;
4551 }
4552 RaCursorOffset = 0;
4553 RaWindowCursorX = 0;
4554 ArgusTouchScreen();
4555 }
4556 break;
4557 }
4558 }
4559 }
4560
4561 RaInputStatus = RAGOTcolon;
4562 RaInputString = RANEWCOMMANDSTR;
4563 bzero(RaCommandInputStr, MAXSTRLEN);
4564 RaCommandIndex = 0;
4565
4566 cbreak();
4567 RaCursesSetWindowFocus(ArgusParser, RaCurrentWindow->window);
4568 if (sbuf != NULL) ArgusFree(sbuf);
4569
4570 #if defined(ARGUS_HISTORY)
4571 argus_enable_history();
4572 #endif
4573 }
4574
4575
4576 int
argus_process_command(struct ArgusParserStruct * parser,int status)4577 argus_process_command (struct ArgusParserStruct *parser, int status)
4578 {
4579 char promptbuf[256], *prompt = promptbuf;
4580 int retn = status;
4581
4582 if (strlen(rl_line_buffer) == 1) {
4583 switch (*rl_line_buffer) {
4584 case 'a': {
4585 retn = RAGETTINGa;
4586 RaInputString = RAGETTINGaSTR;
4587 break;
4588 }
4589
4590 case 'c': {
4591 break;
4592 }
4593
4594 case 'd': {
4595 struct ArgusInput *input;
4596 retn = RAGETTINGd;
4597
4598 RaInputString = RAGETTINGdSTR;
4599
4600 if ((input = (void *)ArgusParser->ArgusActiveHosts->start) != NULL) {
4601 do {
4602 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s:%d ", input->hostname, input->portnum);
4603 input = (void *)input->qhdr.nxt;
4604 } while (input != (void *)ArgusParser->ArgusActiveHosts->start);
4605 }
4606 RaCommandIndex = strlen(RaCommandInputStr);
4607 break;
4608 }
4609
4610 case 'D': {
4611 retn = RAGETTINGD;
4612 RaInputString = RAGETTINGDSTR;
4613 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d", ArgusParser->debugflag);
4614 RaCommandIndex = strlen(RaCommandInputStr);
4615 break;
4616 }
4617
4618 case 'e': {
4619 retn = RAGETTINGe;
4620 RaInputString = RAGETTINGeSTR;
4621 if (ArgusParser->estr)
4622 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", ArgusParser->estr);
4623 RaCommandIndex = strlen(RaCommandInputStr);
4624 break;
4625 }
4626
4627 case 'f':
4628 retn = RAGETTINGf;
4629 RaInputString = RAGETTINGfSTR;
4630 RaFilterIndex = 3;
4631 if (ArgusParser->ArgusRemoteFilter) {
4632 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "remote %s ", ArgusParser->ArgusRemoteFilter);
4633 RaCommandIndex = strlen(RaCommandInputStr);
4634 RaFilterIndex = ARGUS_REMOTE_FILTER;
4635 } else
4636 if (ArgusParser->ArgusLocalFilter) {
4637 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "local %s ", ArgusParser->ArgusLocalFilter);
4638 RaCommandIndex = strlen(RaCommandInputStr);
4639 RaFilterIndex = ARGUS_LOCAL_FILTER;
4640 } else
4641 if (ArgusParser->ArgusDisplayFilter) {
4642 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "display %s ", ArgusParser->ArgusDisplayFilter);
4643 RaCommandIndex = strlen(RaCommandInputStr);
4644 RaFilterIndex = ARGUS_DISPLAY_FILTER;
4645 }
4646 break;
4647
4648 case 'm': {
4649 struct ArgusAggregatorStruct *agg = ArgusParser->ArgusAggregator;
4650 struct ArgusMaskStruct *ArgusMaskDefs = ArgusIpV4MaskDefs;
4651 int i;
4652
4653 retn = RAGETTINGm;
4654 RaInputString = RAGETTINGmSTR;
4655 if (agg->modeStr != NULL) {
4656 sprintf (RaCommandInputStr, "%s", agg->modeStr);
4657 } else {
4658 for (i = 0; i < ARGUS_MAX_MASK_LIST; i++) {
4659 if (agg->mask & (0x01LL << i)) {
4660 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", ArgusMaskDefs[i].name);
4661
4662 switch (i) {
4663 case ARGUS_MASK_SADDR:
4664 if (agg->saddrlen > 0)
4665 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "/%d", agg->saddrlen);
4666 break;
4667 case ARGUS_MASK_DADDR:
4668 if (agg->daddrlen > 0)
4669 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "/%d", agg->daddrlen);
4670 break;
4671 }
4672
4673 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], " ");
4674 }
4675 }
4676
4677 agg->modeStr = strdup(RaCommandInputStr);
4678 }
4679 RaCommandIndex = strlen(RaCommandInputStr);
4680 break;
4681 }
4682
4683 case 'M': {
4684 struct ArgusModeStruct *mode;
4685 retn = RAGETTINGM;
4686 RaInputString = RAGETTINGMSTR;
4687
4688 if ((mode = ArgusParser->ArgusModeList) != NULL) {
4689 while (mode) {
4690 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s ", mode->mode);
4691 mode = mode->nxt;
4692 }
4693 }
4694 RaCommandIndex = strlen(RaCommandInputStr);
4695 break;
4696 }
4697
4698 case 'N':
4699 retn = RAGETTINGN;
4700 RaInputString = RAGETTINGNSTR;
4701 break;
4702
4703 case 'n': {
4704 char *name = NULL;
4705 retn = RAGETTINGn;
4706 RaInputString = RAGETTINGnSTR;
4707 switch (ArgusParser->nflag) {
4708 case 0: name = "all"; break;
4709 case 1: name = "port"; break;
4710 case 2: name = "proto"; break;
4711 case 3: name = "none"; break;
4712 default: name = "port"; ArgusParser->nflag = 1; break;
4713 }
4714 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", name);
4715 RaCommandIndex = strlen(RaCommandInputStr);
4716 break;
4717 }
4718
4719 case 'p': {
4720 retn = RAGETTINGp;
4721 RaInputString = RAGETTINGpSTR;
4722 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d", ArgusParser->pflag);
4723 RaCommandIndex = strlen(RaCommandInputStr);
4724 break;
4725 }
4726
4727 case '\\': {
4728 ArgusParser->Pauseflag = (ArgusParser->Pauseflag > 0.0) ? 0.0 : 1.0;
4729 if (ArgusParser->Pauseflag)
4730 ArgusSetDebugString ("Paused", LOG_ERR, ARGUS_LOCK);
4731 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
4732 rl_done = 1;
4733 #endif
4734 break;
4735 }
4736
4737 case 't':
4738 retn = RAGETTINGt;
4739 RaInputString = RAGETTINGtSTR;
4740 if (ArgusParser->timearg) {
4741 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s", ArgusParser->timearg);
4742 RaCommandIndex = strlen(RaCommandInputStr);
4743 } else {
4744 }
4745 break;
4746
4747 case 'T':
4748 retn = RAGETTINGT;
4749 RaInputString = RAGETTINGTSTR;
4750 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d.%06d",
4751 (int)ArgusParser->timeout.tv_sec, (int)ArgusParser->timeout.tv_usec);
4752 RaCommandIndex = strlen(RaCommandInputStr);
4753 break;
4754
4755 case 'R': {
4756 struct ArgusInput *input = ArgusParser->ArgusInputFileList;
4757 retn = RAGETTINGR;
4758 RaInputString = RAGETTINGRSTR;
4759 while (input) {
4760 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s ", input->filename);
4761 RaCommandIndex = strlen(RaCommandInputStr);
4762 input = (void *) input->qhdr.nxt;
4763 }
4764 break;
4765 }
4766
4767 case 'r': {
4768 struct ArgusInput *input = ArgusParser->ArgusInputFileList;
4769 retn = RAGETTINGr;
4770 RaInputString = RAGETTINGrSTR;
4771 while (input) {
4772 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s ", input->filename);
4773 RaCommandIndex = strlen(RaCommandInputStr);
4774 input = (void *) input->qhdr.nxt;
4775 }
4776 break;
4777 }
4778
4779 case 'S': {
4780 struct ArgusInput *input;
4781 retn = RAGETTINGS;
4782 RaInputString = RAGETTINGSSTR;
4783
4784 if ((input = (void *)ArgusParser->ArgusActiveHosts->start) != NULL) {
4785 do {
4786 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s:%d ", input->hostname, input->portnum);
4787 input = (void *)input->qhdr.nxt;
4788 } while (input != (void *)ArgusParser->ArgusActiveHosts->start);
4789
4790 RaCommandIndex = strlen(RaCommandInputStr);
4791 }
4792 break;
4793 }
4794
4795 case 'P': {
4796 int x, y;
4797 retn = RAGETTINGs;
4798 RaInputString = RAGETTINGsSTR;
4799 for (x = 0; x < ARGUS_MAX_SORT_ALG; x++) {
4800 if (ArgusSorter->ArgusSortAlgorithms[x]) {
4801 for (y = 0; y < ARGUS_MAX_SORT_ALG; y++) {
4802 if (ArgusSorter->ArgusSortAlgorithms[x] == ArgusSortAlgorithmTable[y]) {
4803 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s ",
4804 ArgusSortKeyWords[y]);
4805 break;
4806 }
4807 }
4808 }
4809 }
4810 RaCommandIndex = strlen(RaCommandInputStr);
4811 break;
4812 }
4813
4814 case 'u':
4815 retn = RAGETTINGu;
4816 RaInputString = RAGETTINGuSTR;
4817 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%d.", (int) RaCursesUpdateInterval.tv_sec);
4818 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%06d",(int) RaCursesUpdateInterval.tv_usec);
4819 RaCommandIndex = strlen(RaCommandInputStr);
4820 break;
4821
4822 case 'U':
4823 retn = RAGETTINGU;
4824 RaInputString = RAGETTINGUSTR;
4825 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%2.2f", RaUpdateRate);
4826 RaCommandIndex = strlen(RaCommandInputStr);
4827 break;
4828
4829 case 'w':
4830 retn = RAGETTINGw;
4831 RaInputString = RAGETTINGwSTR;
4832 break;
4833
4834 case 's': {
4835 int x, y;
4836
4837 RaInputString = RAGETTINGFSTR;
4838 retn = RAGETTINGF;
4839
4840 for (x = 0; x < MAX_PRINT_ALG_TYPES; x++) {
4841 if (parser->RaPrintAlgorithmList[x] != NULL) {
4842 for (y = 0; y < MAX_PRINT_ALG_TYPES; y++) {
4843 if ((void *) parser->RaPrintAlgorithmList[x]->print == (void *) RaPrintAlgorithmTable[y].print) {
4844 sprintf (&RaCommandInputStr[strlen(RaCommandInputStr)], "%s:%d ",
4845 RaPrintAlgorithmTable[y].field, RaPrintAlgorithmTable[y].length);
4846 break;
4847 }
4848 }
4849 } else
4850 break;
4851 }
4852 RaCommandIndex = strlen(RaCommandInputStr);
4853 break;
4854 }
4855
4856 case 'Q':
4857 retn = RAGETTINGq;
4858 RaInputString = RAGETTINGqSTR;
4859 break;
4860
4861 case 'h':
4862 retn = RAGETTINGh;
4863 RaInputString = RAGETTINGhSTR;
4864 RaWindowStatus = 0;
4865 RaOutputHelpScreen();
4866 break;
4867
4868 case 'v':
4869 if (ArgusParser->vflag) {
4870 ArgusParser->vflag = 0;
4871 ArgusReverseSortDir = 0;
4872 } else {
4873 ArgusParser->vflag = 1;
4874 ArgusReverseSortDir++;
4875 }
4876
4877 RaClientSortQueue(ArgusSorter, RaCursesProcess->queue, ARGUS_LOCK);
4878
4879 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
4880 rl_done = 1;
4881 #endif
4882 break;
4883
4884 case '=': {
4885 struct ArgusRecordStruct *ns = NULL;
4886
4887 werase(RaCurrentWindow->window);
4888 ArgusTouchScreen();
4889
4890 #if defined(ARGUS_THREADS)
4891 pthread_mutex_lock(&RaCursesProcess->queue->lock);
4892 #endif
4893 while ((ns = (struct ArgusRecordStruct *) ArgusPopQueue(RaCursesProcess->queue, ARGUS_NOLOCK)) != NULL) {
4894 if (ArgusSearchHitRecord == ns) {
4895 ArgusResetSearch();
4896 }
4897 ArgusDeleteRecordStruct (ArgusParser, ns);
4898 }
4899
4900 ArgusEmptyHashTable(RaCursesProcess->htable);
4901 if (ArgusParser->ns) {
4902 ArgusDeleteRecordStruct (ArgusParser, ArgusParser->ns);
4903 ArgusParser->ns = NULL;
4904 }
4905 ArgusParser->RaClientUpdate.tv_sec = 0;
4906 ArgusParser->ArgusTotalRecords = 0;
4907 RaCursesStartTime.tv_sec = 0;
4908 RaCursesStartTime.tv_usec = 0;
4909 RaCursesStopTime.tv_sec = 0;
4910 RaCursesStopTime.tv_usec = 0;
4911 #if defined(ARGUS_THREADS)
4912 pthread_mutex_unlock(&RaCursesProcess->queue->lock);
4913 #endif
4914 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
4915 rl_done = 1;
4916 #endif
4917 break;
4918 }
4919
4920 case 'z':
4921 if (++ArgusParser->zflag > 1) {
4922 ArgusParser->zflag = 0;
4923 }
4924 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
4925 rl_done = 1;
4926 #endif
4927 break;
4928
4929 case 'Z':
4930 switch (ArgusParser->Zflag) {
4931 case '\0': ArgusParser->Zflag = 'b'; break;
4932 case 'b': ArgusParser->Zflag = 's'; break;
4933 case 's': ArgusParser->Zflag = 'd'; break;
4934 case 'd': ArgusParser->Zflag = '\0'; break;
4935 }
4936 #if defined(HAVE_DECL_RL_DONE) && HAVE_DECL_RL_DONE
4937 rl_done = 1;
4938 #endif
4939 break;
4940
4941 default:
4942 break;
4943 }
4944
4945 if (retn != status) {
4946 sprintf (prompt, ":%s ", RaInputString);
4947
4948 rl_set_prompt(prompt);
4949
4950 #if defined(HAVE_DECL_RL_SAVE_PROMPT) && HAVE_DECL_RL_SAVE_PROMPT
4951 rl_save_prompt();
4952 #endif
4953
4954 #if defined(ARGUS_READLINE)
4955 #if defined(HAVE_DECL_RL_REPLACE_LINE) && HAVE_DECL_RL_REPLACE_LINE
4956 rl_replace_line(RaCommandInputStr, 1);
4957 #else
4958 #if defined(HAVE_DECL_RL_DELETE_TEXT) && HAVE_DECL_RL_DELETE_TEXT
4959 rl_delete_text(0, rl_point);
4960 #endif
4961 sprintf(rl_line_buffer, "%s", RaCommandInputStr);
4962 #endif
4963 rl_point = strlen(rl_line_buffer);
4964 rl_end = rl_point;
4965 #else
4966 #endif
4967 }
4968 }
4969
4970 return (retn);
4971 }
4972
4973
4974 #endif
4975
4976 #if defined(ARGUS_HISTORY)
4977
4978 char ratop_historybuf[MAXSTRLEN];
4979 char *ratop_history = NULL;
4980
4981 int argus_history_enabled = 1;
4982
4983 void
argus_recall_history(void)4984 argus_recall_history(void)
4985 {
4986 if (ratop_history != NULL)
4987 read_history(ratop_history);
4988 }
4989
4990 void
argus_save_history(void)4991 argus_save_history(void)
4992 {
4993 if (ratop_history == NULL) {
4994 char *home;
4995
4996 if ((home = getenv("HOME")) != NULL) {
4997 sprintf (ratop_historybuf, "%s/.ratop_history", home);
4998 ratop_history = ratop_historybuf;
4999 }
5000 }
5001
5002 if (ratop_history != NULL)
5003 write_history(ratop_history);
5004 }
5005
5006 void
argus_enable_history(void)5007 argus_enable_history(void)
5008 {
5009 argus_recall_history();
5010 argus_history_enabled = 1;
5011 }
5012
5013
5014 void
argus_disable_history(void)5015 argus_disable_history(void)
5016 {
5017 argus_save_history();
5018 clear_history();
5019 argus_history_enabled = 0;
5020 }
5021
5022 int
argus_history_is_enabled(void)5023 argus_history_is_enabled(void)
5024 {
5025 return (argus_history_enabled);
5026 }
5027
5028 #endif // ARGUS_HISTORY
5029
5030
5031 void
RaRefreshDisplay(void)5032 RaRefreshDisplay (void)
5033 {
5034 #if defined(ARGUS_CURSES)
5035 struct timeval tvpbuf, *tvp = &tvpbuf;
5036
5037 gettimeofday (tvp, NULL);
5038
5039 if (RaCursesUpdateTime.tv_sec == 0)
5040 RaCursesUpdateTime = *tvp;
5041
5042 if (RaWindowImmediate || ((RaCursesUpdateTime.tv_sec < tvp->tv_sec) ||
5043 ((RaCursesUpdateTime.tv_sec == tvp->tv_sec) &&
5044 (RaCursesUpdateTime.tv_usec <= tvp->tv_usec)))) {
5045 int cnt, i;
5046
5047 RaCursesUpdateTime = *tvp;
5048
5049 RaCursesUpdateTime.tv_sec += RaCursesUpdateInterval.tv_sec;
5050 RaCursesUpdateTime.tv_usec += RaCursesUpdateInterval.tv_usec;
5051
5052 if (RaCursesUpdateTime.tv_usec >= 1000000) {
5053 RaCursesUpdateTime.tv_sec += 1;
5054 RaCursesUpdateTime.tv_usec -= 1000000;
5055 }
5056
5057 if ((cnt = ArgusWindowQueue->count) > 0) {
5058 for (i = 0; i < cnt; i++) {
5059 struct ArgusWindowStruct *ws = (struct ArgusWindowStruct *)ArgusPopQueue(ArgusWindowQueue, ARGUS_LOCK);
5060 wnoutrefresh(ws->window);
5061 ArgusAddToQueue (ArgusWindowQueue, &ws->qhdr, ARGUS_LOCK);
5062 }
5063 }
5064 doupdate();
5065
5066 RaWindowModified = 0;
5067 RaWindowImmediate = FALSE;
5068 }
5069 #endif
5070 }
5071
5072
5073 #if defined(ARGUS_CURSES)
5074 void
RaUpdateHeaderWindow(WINDOW * win)5075 RaUpdateHeaderWindow(WINDOW *win)
5076 {
5077 #if defined(ARGUS_CURSES)
5078 struct tm *tm, tmbuf;
5079 char stimebuf[128];
5080 #endif
5081
5082 struct timeval tvpbuf, *tvp = &tvpbuf;
5083
5084 gettimeofday (tvp, NULL);
5085
5086 if (tvp->tv_sec > 0) {
5087 time_t tsec = tvp->tv_sec;
5088 tm = localtime_r(&tsec, &tmbuf);
5089 strftime ((char *) stimebuf, 32, "%Y/%m/%d.%T", tm);
5090 sprintf ((char *)&stimebuf[strlen(stimebuf)], " ");
5091 strftime(&stimebuf[strlen(stimebuf)], 32, "%Z ", tm);
5092
5093 } else
5094 sprintf (stimebuf, " ");
5095
5096 mvwaddnstr (win, 0, 0, ArgusGenerateProgramArgs(ArgusParser), RaScreenColumns - 5);
5097 wclrtoeol(win);
5098 mvwaddnstr (win, 0, RaScreenColumns - strlen(stimebuf) , stimebuf, strlen(stimebuf));
5099 touchwin(win);
5100 }
5101
5102 void
RaUpdateDebugWindow(WINDOW * win)5103 RaUpdateDebugWindow(WINDOW *win)
5104 {
5105 char strbuf[MAXSTRLEN];
5106 int len = 0;
5107 #if defined(ARGUS_COLOR_SUPPORT)
5108 int attrs = 0;
5109 #endif
5110
5111 if (ArgusDisplayStatus && (ArgusParser->debugflag == 0)) {
5112 char tbuf[MAXSTRLEN];
5113 struct timeval dtime;
5114 float secs, rate;
5115
5116 dtime.tv_sec = RaCursesStopTime.tv_sec - RaCursesStartTime.tv_sec;
5117 dtime.tv_usec = RaCursesStopTime.tv_usec - RaCursesStartTime.tv_usec;
5118
5119 if (dtime.tv_usec < 0) {
5120 dtime.tv_sec--;
5121 dtime.tv_usec += 1000000;
5122 }
5123
5124 secs = (dtime.tv_sec * 1.0) + ((dtime.tv_usec * 1.0)/1000000.0);
5125 rate = (ArgusParser->ArgusTotalRecords * 1.0);
5126
5127 sprintf (tbuf, "ProcessQueue %6d DisplayQueue %6d TotalRecords %8lld Rate %11.4f rps Status %s",
5128 RaCursesProcess->queue->count, RaSortItems,
5129 ArgusParser->ArgusTotalRecords, rate/secs,
5130 ArgusParser->RaTasksToDo ? "Active" : "Idle");
5131
5132 ArgusSetDebugString (tbuf, 0, ARGUS_LOCK);
5133 }
5134
5135 #if defined(ARGUS_COLOR_SUPPORT)
5136 if (ArgusTerminalColors) {
5137 if (ArgusParser->RaDebugStatus == LOG_ERR)
5138 attrs = COLOR_PAIR(ARGUS_RED);
5139 else
5140 attrs = COLOR_PAIR(ARGUS_BASE2);
5141
5142 wattron(win, attrs);
5143 }
5144 #endif
5145 ArgusCopyDebugString (strbuf, MAXSTRLEN);
5146 len = strlen(strbuf);
5147 len = (len >= RaScreenColumns) ? RaScreenColumns - 1 : len;
5148 strbuf[len] = '\0';
5149 mvwprintw (win, 0, 0, "%s", strbuf);
5150 wclrtoeol(win);
5151
5152 #if defined(ARGUS_COLOR_SUPPORT)
5153 if (ArgusTerminalColors) {
5154 wattroff(RaCurrentWindow->window, attrs);
5155 }
5156 #endif
5157 }
5158
5159 void
RaUpdateStatusWindow(WINDOW * win)5160 RaUpdateStatusWindow(WINDOW *win)
5161 {
5162 if (strlen(RaInputString) == 0) {
5163 mvwaddnstr (win, 0, 0, " ", 1);
5164 wclrtoeol(win);
5165 }
5166 }
5167
5168 int
RaHighlightDisplay(struct ArgusParserStruct * parser,struct ArgusQueueStruct * queue,char * pattern)5169 RaHighlightDisplay (struct ArgusParserStruct *parser, struct ArgusQueueStruct *queue, char *pattern)
5170 {
5171 int retn = -1, x = 0, cursy = 0, refresh = 0, options, rege;
5172 struct ArgusRecordStruct *ns = NULL;
5173 regex_t pregbuf, *preg = &pregbuf;
5174 regmatch_t pmbuf[32], *pm = &pmbuf[0];
5175 char *sbuf = NULL;
5176
5177 if ((sbuf = (char *)ArgusMalloc(MAXSTRLEN)) == NULL)
5178 ArgusLog (LOG_ERR, "RaSQLProcessQueue: ArgusMalloc error %s", strerror(errno));
5179
5180 #if defined(ARGUS_PCRE)
5181 options = 0;
5182 #else
5183 options = REG_EXTENDED | REG_NEWLINE;
5184 #if defined(REG_ENHANCED)
5185 options |= REG_ENHANCED;
5186 #endif
5187 #endif
5188
5189 bzero (preg, sizeof(*preg));
5190
5191 if ((rege = regcomp(preg, pattern, options)) != 0) {
5192 char errbuf[MAXSTRLEN];
5193 if (regerror(rege, preg, errbuf, MAXSTRLEN))
5194 sprintf (sbuf, "RaHighlightDisplay %s", errbuf);
5195 ArgusSetDebugString (sbuf, LOG_ERR, ARGUS_LOCK);
5196 return retn;
5197 }
5198
5199 if (queue->array != NULL) {
5200 char *sptr;
5201 int cnt = queue->count;
5202 int dlen = RaWindowStartLine + RaDisplayLines;
5203
5204 cnt = (dlen > cnt) ? cnt : dlen;
5205
5206 for (x = RaWindowStartLine; x < cnt; x++) {
5207 cursy++;
5208 if ((ns = (struct ArgusRecordStruct *) queue->array[x]) != NULL) {
5209 if ((sptr = ns->disp.str) != NULL) {
5210 int cursx = 0;
5211
5212 bzero(pm, sizeof(*pm));
5213 while ((retn = regexec(preg, sptr, 1, pm, 0)) == 0) {
5214 int span = pm->rm_eo - pm->rm_so;
5215 cursx += pm->rm_so;
5216 #if defined(ARGUS_COLOR_SUPPORT)
5217
5218
5219 if (ArgusTerminalColors) {
5220 mvwchgat(RaCurrentWindow->window, cursy, cursx, span, 0, ArgusColorHighlight, NULL);
5221 }
5222 #endif
5223 sptr += pm->rm_eo;
5224 cursx += span;
5225 refresh = 1;
5226 }
5227 }
5228 }
5229 }
5230 }
5231 if (refresh)
5232 touchwin(RaCurrentWindow->window);
5233
5234 regfree(preg);
5235 if (sbuf != NULL) ArgusFree(sbuf);
5236
5237 return (retn);
5238 }
5239
5240 int
RaSearchDisplay(struct ArgusParserStruct * parser,struct ArgusQueueStruct * queue,int dir,int * cursx,int * cursy,char * pattern,int type)5241 RaSearchDisplay (struct ArgusParserStruct *parser, struct ArgusQueueStruct *queue,
5242 int dir, int *cursx, int *cursy, char *pattern, int type)
5243 {
5244 int retn = -1, x = 0, startline = *cursy, options, rege;
5245 struct ArgusRecordStruct *ns = NULL;
5246 regex_t pregbuf, *preg = &pregbuf;
5247 char *buf = NULL, *ptr = NULL;
5248
5249 if ((buf = (char *)ArgusMalloc(MAXSTRLEN)) == NULL)
5250 ArgusLog (LOG_ERR, "RaSQLProcessQueue: ArgusMalloc error %s", strerror(errno));
5251
5252 #if defined(ARGUS_PCRE)
5253 options = 0;
5254 #else
5255 options = REG_EXTENDED | REG_NEWLINE;
5256 #if defined(REG_ENHANCED)
5257 options |= REG_ENHANCED;
5258 #endif
5259 #endif
5260
5261 bzero (preg, sizeof(*preg));
5262
5263 if ((rege = regcomp(preg, pattern, options)) != 0) {
5264 char errbuf[MAXSTRLEN];
5265 if (regerror(rege, preg, errbuf, MAXSTRLEN))
5266 sprintf (buf, "RaSearchDisplay %s", errbuf);
5267 ArgusSetDebugString (buf, LOG_ERR, ARGUS_LOCK);
5268 return retn;
5269 }
5270
5271 #if defined(ARGUS_THREADS)
5272 if (type == ARGUS_LOCK)
5273 pthread_mutex_lock(&queue->lock);
5274 #endif
5275
5276 if (queue->array != NULL) {
5277 if (startline == 0) {
5278 *cursy = 1; startline = 1;
5279 }
5280
5281 if (queue->arraylen >= startline) {
5282 if ((ns = (struct ArgusRecordStruct *) queue->array[startline - 1]) != NULL) {
5283 int offset = *cursx, found = 0;
5284 char buf[MAXSTRLEN];
5285
5286 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != startline)) {
5287 if (ns->disp.str != NULL)
5288 free(ns->disp.str);
5289
5290 buf[0] = '\0';
5291 ns->rank = startline;
5292 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
5293 ns->disp.str = strdup(buf);
5294 ns->status &= ~ARGUS_RECORD_MODIFIED;
5295 }
5296
5297 bcopy(ns->disp.str, buf, strlen(ns->disp.str) + 1);
5298
5299 switch (dir) {
5300 case ARGUS_FORWARD: {
5301 regmatch_t pmbuf[32], *pm = &pmbuf[0];
5302 int rege, nmatch = 1;
5303 char *p = &buf[offset];
5304
5305 if ((rege = regexec(preg, p, nmatch, pm, 0)) == 0) {
5306 if (pm->rm_so == 0) {
5307 if (regexec(preg, p + 1, nmatch, pm, 0) == 0) {
5308 offset += pm->rm_so + 1;
5309 found++;
5310 }
5311 } else {
5312 offset += pm->rm_so;
5313 found++;
5314 }
5315 if (found) {
5316 retn = *cursy;
5317 *cursx = offset;
5318 #if defined(ARGUS_THREADS)
5319 if (type == ARGUS_LOCK)
5320 pthread_mutex_unlock(&queue->lock);
5321 #endif
5322 ArgusSearchHitRecord = ns;
5323 ArgusSearchHitRank = ns->rank;
5324 return (retn);
5325 }
5326 }
5327 break;
5328 }
5329
5330 case ARGUS_BACKWARD: {
5331 char *lastmatch = NULL;
5332 buf[offset] = '\0';
5333 ptr = buf;
5334 while ((ptr = strstr(ptr, pattern)) != NULL)
5335 lastmatch = ptr++;
5336
5337 if (lastmatch) {
5338 retn = *cursy;
5339 *cursx = (lastmatch - buf);
5340 #if defined(ARGUS_THREADS)
5341 if (type == ARGUS_LOCK)
5342 pthread_mutex_unlock(&queue->lock);
5343 #endif
5344 ArgusSearchHitRecord = ns;
5345 ArgusSearchHitRank = ns->rank;
5346 return (retn);
5347 }
5348 break;
5349 }
5350 }
5351 }
5352
5353 switch (dir) {
5354 case ARGUS_FORWARD:
5355 for (x = startline; x < queue->arraylen; x++) {
5356 if ((ns = (struct ArgusRecordStruct *) queue->array[x]) != NULL) {
5357 regmatch_t pmbuf[32], *pm = &pmbuf[0];
5358 char buf[MAXSTRLEN];
5359
5360 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != (x + 1))) {
5361 if (ns->disp.str != NULL)
5362 free(ns->disp.str);
5363
5364 buf[0] = '\0';
5365 ns->rank = (x + 1);
5366 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
5367 ns->disp.str = strdup(buf);
5368 ns->status &= ~ARGUS_RECORD_MODIFIED;
5369 }
5370
5371 bcopy(ns->disp.str, buf, strlen(ns->disp.str) + 1);
5372
5373 if ((retn = regexec(preg, buf, 1, pm, 0)) == 0) {
5374 retn = x + 1;
5375 *cursx = pm->rm_so;
5376 *cursy = retn;
5377 #if defined(ARGUS_THREADS)
5378 if (type == ARGUS_LOCK)
5379 pthread_mutex_unlock(&queue->lock);
5380 #endif
5381 ArgusSearchHitRecord = ns;
5382 ArgusSearchHitRank = ns->rank;
5383 return (retn);
5384 break;
5385 }
5386 }
5387 }
5388 break;
5389
5390 case ARGUS_BACKWARD: {
5391 for (x = (startline - 2); x >= 0; x--) {
5392 if ((ns = (struct ArgusRecordStruct *) queue->array[x]) != NULL) {
5393 char *lastmatch = NULL;
5394 char buf[MAXSTRLEN];
5395
5396 if (((ns->disp.str == NULL) || (ns->status & ARGUS_RECORD_MODIFIED)) || (ns->rank != (x + 1))) {
5397 if (ns->disp.str != NULL)
5398 free(ns->disp.str);
5399
5400 buf[0] = '\0';
5401 ns->rank = x + 1;
5402 ArgusPrintRecord(parser, buf, ns, MAXSTRLEN);
5403 ns->disp.str = strdup(buf);
5404 ns->status &= ~ARGUS_RECORD_MODIFIED;
5405 }
5406
5407 bcopy(ns->disp.str, buf, strlen(ns->disp.str) + 1);
5408
5409 ptr = buf;
5410 while ((ptr = strstr(ptr, pattern)) != NULL)
5411 lastmatch = ptr++;
5412
5413 if (lastmatch) {
5414 retn = x + 1;
5415 *cursx = (lastmatch - buf);
5416 *cursy = retn;
5417 #if defined(ARGUS_THREADS)
5418 if (type == ARGUS_LOCK)
5419 pthread_mutex_unlock(&queue->lock);
5420 #endif
5421 ArgusSearchHitRecord = ns;
5422 ArgusSearchHitRank = ns->rank;
5423 return (retn);
5424 }
5425 }
5426 }
5427 break;
5428 }
5429 }
5430 }
5431 }
5432 #if defined(ARGUS_THREADS)
5433 if (type == ARGUS_LOCK)
5434 pthread_mutex_unlock(&queue->lock);
5435 #endif
5436
5437 ArgusSearchHitRecord = NULL;
5438 ArgusSearchHitRank = 0;
5439 regfree(preg);
5440 if (buf != NULL) ArgusFree(buf);
5441 return (-1);
5442 }
5443
5444 void
ArgusResetSearch(void)5445 ArgusResetSearch (void)
5446 {
5447 ArgusSearchHitRecord = NULL;
5448 ArgusSearchHitRank = 0;
5449 RaWindowCursorY = 1;
5450 RaWindowCursorX = 0;
5451 RaWindowStartLine = 0;
5452 }
5453
5454
5455 void
RaResizeScreen(void)5456 RaResizeScreen(void)
5457 {
5458 struct ArgusQueueStruct *queue = RaCursesProcess->queue;
5459 struct winsize size;
5460 int i, count;
5461
5462 if (ioctl(fileno(stdout), TIOCGWINSZ, &size) == 0) {
5463 #if defined(__FreeBSD__) || (__NetBSD__) || (__OpenBSD__)
5464 resizeterm(size.ws_row, size.ws_col);
5465 #else
5466 #if defined(ARGUS_SOLARIS)
5467 #else
5468 resize_term(size.ws_row, size.ws_col);
5469 #endif
5470 #endif
5471 }
5472
5473 getmaxyx(stdscr, RaScreenLines, RaScreenColumns);
5474 #if defined(ARGUS_READLINE)
5475 rl_set_screen_size(RaScreenLines - 1, RaScreenColumns);
5476 #endif
5477
5478 RaWindowLines = RaScreenLines - (RaHeaderWinSize + RaStatusWinSize + RaDebugWinSize);
5479 RaDisplayLines = RaWindowLines;
5480
5481 #if !defined(ARGUS_SOLARIS)
5482 wresize(RaHeaderWindow, RaHeaderWinSize, RaScreenColumns);
5483 wresize(RaDebugWindow, RaDebugWinSize, RaScreenColumns);
5484 wresize(RaStatusWindow, RaStatusWinSize, RaScreenColumns);
5485
5486 if (mvwin(RaDebugWindow, RaScreenLines - 2, RaScreenStartX) == ERR)
5487 ArgusLog (LOG_ERR, "RaResizeScreen: mvwin %d, %d returned ERR\n", RaScreenStartY + 5, RaScreenStartX);
5488
5489 if (mvwin(RaStatusWindow, RaScreenLines - 1, RaScreenStartX) == ERR)
5490 ArgusLog (LOG_ERR, "RaResizeScreen: mvwin %d, %d returned ERR\n", RaScreenStartY + 5, RaScreenStartX);
5491
5492 if ((count = ArgusDomainQueue->count) > 0) {
5493 for (i = 0; i < count; i++) {
5494 struct ArgusDomainStruct *dom = (struct ArgusDomainStruct *)ArgusPopQueue(ArgusDomainQueue, ARGUS_LOCK);
5495 ArgusAddToQueue (ArgusDomainQueue, &dom->qhdr, ARGUS_LOCK);
5496 wresize(dom->ws->window, RaDisplayLines, RaScreenColumns);
5497 }
5498 }
5499
5500 queue->status |= RA_MODIFIED;
5501
5502 #ifdef ARGUSDEBUG
5503 ArgusDebug (1, "RaResizeScreen() y %d x %d\n", RaScreenLines, RaScreenColumns);
5504 #endif
5505
5506 #else
5507 delwin(RaHeaderWindow);
5508 RaHeaderWindow = newwin (RaHeaderWinSize, RaScreenColumns, 0, 0);
5509 idlok (RaHeaderWindow, TRUE);
5510 notimeout(RaHeaderWindow, TRUE);
5511
5512 if ((count = ArgusDomainQueue->count) > 0) {
5513 for (i = 0; i < count; i++) {
5514 struct ArgusDomainStruct *dom = (struct ArgusDomainStruct *)ArgusPopQueue(ArgusDomainQueue, ARGUS_LOCK);
5515 ArgusAddToQueue (ArgusDomainQueue, &dom->qhdr, ARGUS_LOCK);
5516 delwin(dom->ws->window);
5517 dom->ws->window = newwin (RaWindowLines, RaScreenColumns, RaHeaderWinSize, 0);
5518 idlok (dom->ws->window, TRUE);
5519 notimeout(dom->ws->window, TRUE);
5520 }
5521 }
5522
5523 #endif // ARGUS_SOLARIS
5524
5525 ArgusTouchScreen();
5526 RaRefreshDisplay();
5527 RaScreenResize = FALSE;
5528 }
5529
5530
5531 void
RaOutputModifyScreen()5532 RaOutputModifyScreen ()
5533 {
5534 int i = 0;
5535 werase(RaCurrentWindow->window);
5536 for (i = RaMinCommandLines; i < (RaMaxCommandLines + 1); i++) {
5537 mvwprintw (RaCurrentWindow->window, i, 1, RaCommandArray[i - RaMinCommandLines]);
5538 if (i == RaMinCommandLines)
5539 wstandout(RaCurrentWindow->window);
5540 wprintw (RaCurrentWindow->window, "%s", RaCommandValueArray[i - RaMinCommandLines]());
5541 if (i == RaMinCommandLines)
5542 wstandend(RaCurrentWindow->window);
5543 }
5544 }
5545
5546 void
RaOutputHelpScreen()5547 RaOutputHelpScreen ()
5548 {
5549 int i = 0;
5550 extern char version[];
5551
5552 #if defined(ARGUS_THREADS)
5553 pthread_mutex_lock(&RaCursesLock);
5554 #endif
5555 wclear(RaCurrentWindow->window);
5556
5557 mvwprintw (RaCurrentWindow->window, i++, 1, "RaCurses Version %s\n", version);
5558 mvwprintw (RaCurrentWindow->window, i++, 1, "Key Commands: c,d,D,f,h,H,m,n,N,%%,p,P,q,r,R,s,S,t,T,u,U,v,w,z,Z,=");
5559 i++;
5560 mvwprintw (RaCurrentWindow->window, i++, 1, " ^D - Clear command line. Reset input (also ESC).");
5561 mvwprintw (RaCurrentWindow->window, i++, 1, " c - Connect to remote Argus Source");
5562 mvwprintw (RaCurrentWindow->window, i++, 1, " d - Drop connection to remote argus source");
5563 mvwprintw (RaCurrentWindow->window, i++, 1, " D - Set debug printing level");
5564 mvwprintw (RaCurrentWindow->window, i++, 1, " f - Specify filter expression: remote, local and display");
5565
5566 mvwprintw (RaCurrentWindow->window, i++, 1, " h - Print help screen.");
5567 mvwprintw (RaCurrentWindow->window, i++, 1, " H - Toggle number abbreviations.");
5568 mvwprintw (RaCurrentWindow->window, i++, 1, " m - Specify the flow model key objects (see racluster.1).");
5569 mvwprintw (RaCurrentWindow->window, i++, 1, " n - Toggle name to number conversion (cycle through).");
5570 mvwprintw (RaCurrentWindow->window, i++, 1, " N - Specify the number of items to print.");
5571 mvwprintw (RaCurrentWindow->window, i++, 1, " %% - Show percent values.");
5572 mvwprintw (RaCurrentWindow->window, i++, 1, " p - Specify precision.");
5573 mvwprintw (RaCurrentWindow->window, i++, 1, " P - Specify sort fields.");
5574 mvwprintw (RaCurrentWindow->window, i++, 1, " q - Quit the program.");
5575 mvwprintw (RaCurrentWindow->window, i++, 1, " r - Read argus data file(s)");
5576 mvwprintw (RaCurrentWindow->window, i++, 1, " R - Recursively open argus data files(s)");
5577
5578 mvwprintw (RaCurrentWindow->window, i++, 1, " s - Specify fields to print (use arrow keys to navigate).");
5579 mvwprintw (RaCurrentWindow->window, i++, 1, " +[#]field - add field to optional column # or end of line");
5580 mvwprintw (RaCurrentWindow->window, i++, 1, " -field - remove field from display");
5581 mvwprintw (RaCurrentWindow->window, i++, 1, " field - reset fields and add to display");
5582 mvwprintw (RaCurrentWindow->window, i++, 1, " available fields are:");
5583 mvwprintw (RaCurrentWindow->window, i++, 1, " srcid, rank, seq, autoid, stime, ltime, dur, idle, sstime, sltime, sdur, ddur, dstime, dltime, rtime");
5584 mvwprintw (RaCurrentWindow->window, i++, 1, " offset, srng, erng, trans, flgs, mean, stddev, min, max, sum, snet, saddr, dir, dnet, daddr, proto");
5585 mvwprintw (RaCurrentWindow->window, i++, 1, " sport, dport, sco, dco, stos, dtos, sdsb, ddsb, sttl, dttl, shops, dhops, sipid, dipid, pkts");
5586 mvwprintw (RaCurrentWindow->window, i++, 1, " spkts, dpkts, bytes, sbytes, dbytes, appbytes, sappbytes, dappbytes, load, sload, dload");
5587 mvwprintw (RaCurrentWindow->window, i++, 1, " rate, srate, drate, loss, sloss, dloss, ploss, sploss, dploss, retrans, sretrans, dretrans");
5588 mvwprintw (RaCurrentWindow->window, i++, 1, " pretrans, spretrans, dpretrans, sgap, dgap, nstroke, snstroke, dnstroke, senc, denc bssid, ssid");
5589 mvwprintw (RaCurrentWindow->window, i++, 1, " soui, doui, smac, dmac, sas, das, ias, smpls, dmpls, svlan, dvlan, svid, dvid, svpri, dvpri");
5590 mvwprintw (RaCurrentWindow->window, i++, 1, " sintpkt, dintpkt, sintpktact, dintpktact, sintpktidl, dintpktidl, sintpktmax, sintpktmin");
5591 mvwprintw (RaCurrentWindow->window, i++, 1, " dintpktmax, dintpktmin, sintpktactmax, sintpktactmin, dintpktactmax, dintpktactmin");
5592 mvwprintw (RaCurrentWindow->window, i++, 1, " sintpktidlmax, sintpktidlmin, dintpktidlmax, dintpktidlmin, sjit, djit, sjitact, djitact");
5593 mvwprintw (RaCurrentWindow->window, i++, 1, " sjitidl, djitidl, state, cause, resp, dldur, dlstime, dlltime, dspkts, ddpkts, dlspkt, dldpkt");
5594 mvwprintw (RaCurrentWindow->window, i++, 1, " dsbytes, ddbytes, pdspkts, pddpkts, pdsbytes, pddbytes, spktsz, smeansz, smaxsz, sminsz, dpktsz");
5595 mvwprintw (RaCurrentWindow->window, i++, 1, " dmeansz, dmaxsz, dminsz, sintdist, dintdist, sintdistact, dintdistact, sintdistidl, dintdistidl");
5596 mvwprintw (RaCurrentWindow->window, i++, 1, " suser, duser, label, icmpid, tcpopt, tcpext, stcpmax, dtcpmax, swin, dwin, jdelay, ldelay, bins");
5597 mvwprintw (RaCurrentWindow->window, i++, 1, " binnum, stcpb, dtcpb, tcprtt, synack, ackdat, inode, smaxsz, sminsz, dmaxsz, dminsz");
5598 i++;
5599 mvwprintw (RaCurrentWindow->window, i++, 1, " S - Connect to remote Argus Source.");
5600 mvwprintw (RaCurrentWindow->window, i++, 1, " t - Specify time range. same as -t command line option.");
5601 mvwprintw (RaCurrentWindow->window, i++, 1, " T - Specify idle timeout (float) value [60.0s].");
5602 mvwprintw (RaCurrentWindow->window, i++, 1, " u - Specify the window update interval, in seconds [0.1s]");
5603 mvwprintw (RaCurrentWindow->window, i++, 1, " U - Specify the playback rate, in seconds per second [1.0]");
5604 mvwprintw (RaCurrentWindow->window, i++, 1, " v - reverse the sort order");
5605 mvwprintw (RaCurrentWindow->window, i++, 1, " w - Write display to file");
5606 mvwprintw (RaCurrentWindow->window, i++, 1, " z - Toggle State field output formats");
5607 mvwprintw (RaCurrentWindow->window, i++, 1, " Z - Toggle TCP State field output");
5608 mvwprintw (RaCurrentWindow->window, i++, 1, " = - Clear Flow List");
5609 mvwprintw (RaCurrentWindow->window, i++, 1, " \\ - Pause the program");
5610 i++;
5611 mvwprintw (RaCurrentWindow->window, i++, 1, "Navigation Keys (vi): g,G,h,j,k,l,i,w,$,^,^F,^D,^B,^U");
5612
5613 #if defined(ARGUS_THREADS)
5614 pthread_mutex_unlock(&RaCursesLock);
5615 #endif
5616
5617 wrefresh(RaCurrentWindow->window);
5618 }
5619
5620
5621
5622 char *RaDatabase = NULL;
5623 char *RaTable = NULL;
5624
5625 char *
ArgusGenerateProgramArgs(struct ArgusParserStruct * parser)5626 ArgusGenerateProgramArgs(struct ArgusParserStruct *parser)
5627 {
5628 char *retn = RaProgramArgs;
5629 struct ArgusModeStruct *mode = NULL;
5630 struct ArgusInput *input = NULL;
5631
5632 sprintf (retn, "%s ", parser->ArgusProgramName);
5633
5634 if (parser->Aflag) {
5635 sprintf (&retn[strlen(retn)], "-A ");
5636 }
5637 if (parser->ArgusActiveHosts) {
5638 if (parser->Sflag) {
5639 sprintf (&retn[strlen(retn)], "-S ");
5640 if ((input = (void *)parser->ArgusActiveHosts->start) != NULL) {
5641 do {
5642 sprintf (&retn[strlen(retn)], "%s:%d ", input->hostname, input->portnum);
5643 input = (void *)input->qhdr.nxt;
5644 } while (input != (void *)parser->ArgusActiveHosts->start);
5645 }
5646 } else {
5647 sprintf (&retn[strlen(retn)], "-r ");
5648 if ((input = (void *)parser->ArgusInputFileList) != NULL) {
5649 while (input != NULL) {
5650 sprintf (&retn[strlen(retn)], "%s ", input->filename);
5651 input = (void *)input->qhdr.nxt;
5652 }
5653 }
5654 }
5655
5656
5657 } else {
5658 if (RaDatabase && RaTable) {
5659 sprintf (&retn[strlen(retn)], "-P %s:%s ", RaDatabase, RaTable);
5660 }
5661 }
5662
5663 if ((mode = parser->ArgusModeList) != NULL) {
5664 sprintf (&retn[strlen(retn)], "-M ");
5665 while (mode) {
5666 sprintf (&retn[strlen(retn)], "%s ", mode->mode);
5667 mode = mode->nxt;
5668 }
5669 }
5670
5671 if (((mode = parser->ArgusMaskList) != NULL) || ((parser->ArgusAggregator != NULL) && (parser->ArgusAggregator->mask == 0))) {
5672 sprintf (&retn[strlen(retn)], "-m ");
5673 while (mode) {
5674 sprintf (&retn[strlen(retn)], "%s ", mode->mode);
5675 mode = mode->nxt;
5676 }
5677 }
5678
5679 if (parser->Hstr)
5680 sprintf (&retn[strlen(retn)], "-H %s ", parser->Hstr);
5681
5682 if ((parser->ArgusDisplayFilter) || parser->ArgusLocalFilter || parser->ArgusRemoteFilter) {
5683 sprintf (&retn[strlen(retn)], "- ");
5684 if (parser->ArgusDisplayFilter)
5685 sprintf (&retn[strlen(retn)], "display '%s' ", parser->ArgusDisplayFilter);
5686 if (parser->ArgusLocalFilter)
5687 sprintf (&retn[strlen(retn)], "local '%s' ", parser->ArgusLocalFilter);
5688 if (parser->ArgusRemoteFilter)
5689 sprintf (&retn[strlen(retn)], "remote '%s' ", parser->ArgusRemoteFilter);
5690 }
5691 return (retn);
5692 }
5693
5694
5695 #if defined(ARGUS_COLOR_SUPPORT)
5696
5697 int
ArgusColorAvailability(struct ArgusParserStruct * parser,struct ArgusRecordStruct * ns,struct ArgusAttributeStruct * cols,short pair,attr_t attr)5698 ArgusColorAvailability(struct ArgusParserStruct *parser, struct ArgusRecordStruct *ns, struct ArgusAttributeStruct *cols, short pair, attr_t attr)
5699 {
5700 short tpair = pair;
5701 attr_t tattr = attr;
5702 int retn = 0, i;
5703
5704 if (ArgusTerminalColors) {
5705 ArgusProcessServiceAvailability(parser, ns);
5706
5707 if (parser->Aflag && (ns->status & RA_SVCFAILED)) {
5708 tpair = COLOR_PAIR(ARGUS_ORANGE);
5709
5710 for (i = 0; i < RaScreenColumns; i++) {
5711 cols[i].pair = tpair;
5712 cols[i].attr = tattr;
5713 }
5714 }
5715 }
5716 return(retn);
5717 }
5718
5719 int
ArgusColorAddresses(struct ArgusParserStruct * parser,struct ArgusRecordStruct * ns,struct ArgusAttributeStruct * cols,short pair,attr_t attr)5720 ArgusColorAddresses(struct ArgusParserStruct *parser, struct ArgusRecordStruct *ns, struct ArgusAttributeStruct *cols, short pair, attr_t attr)
5721 {
5722 struct ArgusLabelerStruct *labeler = NULL;
5723 int ArgusSrcAddrPair, ArgusDstAddrPair;
5724 int retn = 0;
5725
5726 if (ArgusTerminalColors) {
5727 extern int ArgusTestMulticast( struct ArgusInput *input, unsigned int);
5728 struct ArgusFlow *flow = (struct ArgusFlow *) ns->dsrs[ARGUS_FLOW_INDEX];
5729
5730 ArgusSrcAddrPair = pair;
5731 ArgusDstAddrPair = pair;
5732
5733 switch (ns->hdr.type & 0xF0) {
5734 case ARGUS_MAR:
5735 case ARGUS_EVENT: {
5736 break;
5737 }
5738
5739 case ARGUS_NETFLOW:
5740 case ARGUS_FAR: {
5741 if (flow) {
5742 int i, done;
5743 switch (flow->hdr.subtype & 0x3F) {
5744 case ARGUS_FLOW_CLASSIC5TUPLE:
5745 case ARGUS_FLOW_LAYER_3_MATRIX: {
5746 switch (flow->hdr.argus_dsrvl8.qual & 0x1F) {
5747 case ARGUS_TYPE_IPV4: {
5748 if (ArgusTestMulticast(ns->input, flow->ip_flow.ip_src))
5749 ArgusSrcAddrPair = COLOR_PAIR(ARGUS_BASE00);
5750
5751 if (ArgusTestMulticast(ns->input, flow->ip_flow.ip_dst))
5752 ArgusDstAddrPair = COLOR_PAIR(ARGUS_BASE00);
5753
5754 if ((labeler = parser->ArgusLocalLabeler) != NULL) {
5755 int status;
5756
5757 status = RaProcessAddress (parser, labeler, &flow->ip_flow.ip_src, flow->ip_flow.smask, ARGUS_TYPE_IPV4);
5758 switch (status) {
5759 case ARGUS_MY_ADDRESS: ArgusSrcAddrPair = COLOR_PAIR(ARGUS_BLUE); break;
5760 case ARGUS_MY_NETWORK: ArgusSrcAddrPair = COLOR_PAIR(ARGUS_CYAN); break;
5761 }
5762
5763 status = RaProcessAddress (parser, labeler, &flow->ip_flow.ip_dst, flow->ip_flow.dmask, ARGUS_TYPE_IPV4);
5764 switch (status) {
5765 case ARGUS_MY_ADDRESS: ArgusDstAddrPair = COLOR_PAIR(ARGUS_BLUE); break;
5766 case ARGUS_MY_NETWORK: ArgusDstAddrPair = COLOR_PAIR(ARGUS_CYAN); break;
5767 }
5768 }
5769 break;
5770 }
5771
5772 case ARGUS_TYPE_IPV6: {
5773 #ifndef IN6_IS_ADDR_MULTICAST
5774 #define IN6_IS_ADDR_MULTICAST(a) (((__const uint8_t *) (a))[0] == 0xff)
5775 #endif
5776 if (IN6_IS_ADDR_MULTICAST((struct in6_addr *)&flow->ipv6_flow.ip_src))
5777 ArgusSrcAddrPair = COLOR_PAIR(ARGUS_BASE00);
5778
5779 if (IN6_IS_ADDR_MULTICAST((struct in6_addr *)&flow->ipv6_flow.ip_dst))
5780 ArgusDstAddrPair = COLOR_PAIR(ARGUS_BASE00);
5781
5782 break;
5783 }
5784 }
5785 break;
5786 }
5787
5788 case ARGUS_FLOW_ARP: {
5789 switch (flow->hdr.argus_dsrvl8.qual & 0x1F) {
5790 case ARGUS_TYPE_ARP: {
5791 if ((labeler = parser->ArgusLocalLabeler) != NULL) {
5792 int status;
5793
5794 status = RaProcessAddress (parser, labeler, &flow->arp_flow.arp_spa, 32, ARGUS_TYPE_IPV4);
5795 switch (status) {
5796 case ARGUS_MY_ADDRESS: ArgusSrcAddrPair = COLOR_PAIR(ARGUS_BLUE); break;
5797 case ARGUS_MY_NETWORK: ArgusSrcAddrPair = COLOR_PAIR(ARGUS_CYAN); break;
5798 }
5799
5800 status = RaProcessAddress (parser, labeler, &flow->arp_flow.arp_tpa, 32, ARGUS_TYPE_IPV4);
5801 switch (status) {
5802 case ARGUS_MY_ADDRESS: ArgusDstAddrPair = COLOR_PAIR(ARGUS_BLUE); break;
5803 case ARGUS_MY_NETWORK: ArgusDstAddrPair = COLOR_PAIR(ARGUS_CYAN); break;
5804 }
5805 }
5806 }
5807 }
5808 break;
5809 }
5810 }
5811
5812 for (i = 0, done = 0; i < MAX_PRINT_ALG_TYPES && !done; i++) {
5813 struct ArgusPrintFieldStruct *f;
5814 if ((f = parser->RaPrintAlgorithmList[i]) != NULL) {
5815 int slen = f->length;
5816 int offset = f->offset;
5817 int x;
5818
5819 switch (f->value) {
5820 case ARGUSPRINTSRCADDR: {
5821 f->pair = ArgusSrcAddrPair;
5822 f->attr = attr;
5823 for (x = 0; x < slen; x++) {
5824 cols[offset + x].pair = f->pair;
5825 cols[offset + x].attr = f->attr;
5826 }
5827 break;
5828 }
5829 case ARGUSPRINTDSTADDR: {
5830 f->pair = ArgusDstAddrPair;
5831 f->attr = attr;
5832 for (x = 0; x < slen; x++) {
5833 cols[offset + x].pair = f->pair;
5834 cols[offset + x].attr = f->attr;
5835 }
5836 break;
5837 }
5838 }
5839 } else
5840 done = 1;
5841 }
5842 }
5843 }
5844 }
5845 }
5846 return (retn);
5847 }
5848
5849
5850 int
ArgusColorFlowFields(struct ArgusParserStruct * parser,struct ArgusRecordStruct * ns,struct ArgusAttributeStruct * cols,short pair,attr_t attr)5851 ArgusColorFlowFields(struct ArgusParserStruct *parser, struct ArgusRecordStruct *ns, struct ArgusAttributeStruct *cols, short pair, attr_t attr)
5852 {
5853 struct ArgusLabelerStruct *labeler = parser->ArgusColorLabeler;
5854 int retn = 0;
5855
5856 if (labeler != NULL) {
5857 char *color = RaFlowColor(parser, ns);
5858 if (color != NULL) {
5859 char ptrbuf[1024], *ptr = ptrbuf;
5860 char *tok = NULL;
5861 int i, done;
5862
5863 strncpy(ptr, color, sizeof(ptrbuf));
5864
5865 while ((tok = strsep (&ptr, ";")) != NULL) {
5866 char *cptr, *aptr, *fields = tok;
5867
5868 if ((cptr = strchr(tok, ':')) != NULL) {
5869 char *tfield = fields, *tcolor = NULL, *tattr = NULL;
5870
5871 *cptr++ = '\0';
5872 tcolor = cptr;
5873 if ((aptr = strchr(tcolor, '+')) != NULL) {
5874 *aptr = '\0';
5875 tattr = aptr + 1;
5876 }
5877
5878 if (tcolor) {
5879 switch (*tcolor) {
5880 case 'W': pair = COLOR_PAIR(ARGUS_WHITE); break;
5881 case 'G': pair = COLOR_PAIR(ARGUS_GREEN); break;
5882 case 'B': pair = COLOR_PAIR(ARGUS_BLUE); break;
5883 case 'V': pair = COLOR_PAIR(ARGUS_VIOLET); break;
5884 case 'C': pair = COLOR_PAIR(ARGUS_CYAN); break;
5885 case 'R': pair = COLOR_PAIR(ARGUS_RED); break;
5886 case 'M': pair = COLOR_PAIR(ARGUS_MAGENTA); break;
5887 case 'O': pair = COLOR_PAIR(ARGUS_ORANGE); break;
5888 case 'Y': pair = COLOR_PAIR(ARGUS_YELLOW); break;
5889 default: pair = COLOR_PAIR(ARGUS_BASE0); break;
5890 }
5891 } else
5892 pair = COLOR_PAIR(ARGUS_BASE0);
5893
5894 if (tattr) {
5895 switch (*tattr) {
5896 case 'N': attr = A_NORMAL; break; // Normal display (no highlight)
5897 case 'S': attr = A_STANDOUT; break; // Best highlighting mode of the terminal.
5898 case 'U': attr = A_UNDERLINE; break; // Underlining
5899 case 'R': attr = A_REVERSE; break; // Reverse video
5900 case 'B': attr = A_BLINK; break; // Blinking
5901 case 'D': attr = A_DIM; break; // Half bright
5902 // case 'B': attr = A_BOLD; break; // Extra bright or bold
5903 case 'P': attr = A_PROTECT; break; // Protected mode
5904 case 'I': attr = A_INVIS; break; // Invisible or blank mode
5905 case 'A': attr = A_ALTCHARSET; break; // Alternate character set
5906 case 'C': attr = A_CHARTEXT; break; // Bit-mask to extract a character
5907 default: attr = A_NORMAL; break; // default to normal
5908 }
5909 } else
5910 attr = A_NORMAL; // default to normal
5911
5912 if (!(strcmp("all", tfield))) {
5913 for (i = 0; i < RaScreenColumns; i++) {
5914 cols[i].pair = pair;
5915 cols[i].attr = attr;
5916 }
5917 } else {
5918 for (i = 0, done = 0; i < MAX_PRINT_ALG_TYPES && !done; i++) {
5919 struct ArgusPrintFieldStruct *f;
5920 char *fptr;
5921
5922 if ((f = parser->RaPrintAlgorithmList[i]) != NULL) {
5923 if ((fptr = strstr(tfield, f->field)) != NULL) {
5924 int slen = f->length;
5925 int offset = f->offset;
5926 int x;
5927
5928 for (x = 0; x < slen; x++) {
5929 cols[offset + x].pair = pair;
5930 cols[offset + x].attr = attr;
5931 }
5932 done = 1;
5933 }
5934 } else
5935 done = 1;
5936 }
5937 }
5938 }
5939 }
5940 }
5941 }
5942
5943 return (retn);
5944 }
5945
5946 int
ArgusColorGeoLocation(struct ArgusParserStruct * parser,struct ArgusRecordStruct * ns,struct ArgusAttributeStruct * cols,short pair,attr_t attr)5947 ArgusColorGeoLocation(struct ArgusParserStruct *parser, struct ArgusRecordStruct *ns, struct ArgusAttributeStruct *cols, short pair, attr_t attr)
5948 {
5949 struct ArgusLabelerStruct *labeler = NULL;
5950 int retn = 0;
5951
5952 if (labeler != NULL) {
5953 }
5954
5955 return (retn);
5956 }
5957
5958 int ArgusDisplayColorsInitialized = 0;
5959
5960 void
ArgusInitializeColorMap(struct ArgusParserStruct * parser,WINDOW * win)5961 ArgusInitializeColorMap(struct ArgusParserStruct *parser, WINDOW *win)
5962 {
5963 int i, done;
5964 attr_t attr;
5965 short pair;
5966
5967 wattr_get(win, &attr, &pair, NULL);
5968
5969 for (i = 0, done = 0; i < MAX_PRINT_ALG_TYPES && !done; i++) {
5970 struct ArgusPrintFieldStruct *f;
5971 if ((f = parser->RaPrintAlgorithmList[i]) != NULL) {
5972 switch (f->value) {
5973 case ARGUSPRINTRANK:
5974 f->pair = COLOR_PAIR(ARGUS_BASE01);
5975 f->attr = attr;
5976 break;
5977 default:
5978 f->pair = pair;
5979 f->attr = attr;
5980 break;
5981 }
5982 } else
5983 done = 1;
5984 }
5985 }
5986
5987 int
ArgusGetDisplayLineColor(struct ArgusParserStruct * parser,WINDOW * win,struct ArgusRecordStruct * ns,struct ArgusAttributeStruct * cols)5988 ArgusGetDisplayLineColor(struct ArgusParserStruct *parser, WINDOW *win, struct ArgusRecordStruct *ns, struct ArgusAttributeStruct *cols)
5989 {
5990 int retn = 0, i, done;
5991 attr_t attr;
5992 short pair;
5993
5994 if (!(ArgusDisplayColorsInitialized)) {
5995 ArgusInitializeColorMap(parser, win);
5996 ArgusDisplayColorsInitialized = 1;
5997 }
5998
5999 bzero(cols, sizeof(*cols) * RaScreenColumns);
6000 wattr_get(win, &attr, &pair, NULL);
6001
6002 for (i = 0, done = 0; i < MAX_PRINT_ALG_TYPES && !done; i++) {
6003 struct ArgusPrintFieldStruct *f;
6004 if ((f = parser->RaPrintAlgorithmList[i]) != NULL) {
6005 int slen = f->length;
6006 int offset = f->offset;
6007 int x;
6008
6009 for (x = 0; x < slen; x++) {
6010 cols[offset + x].pair = f->pair;
6011 cols[offset + x].attr = f->attr;
6012 }
6013 } else
6014 done = 1;
6015 }
6016
6017 for (i = 0; i < ARGUS_MAX_COLOR_ALG; i++)
6018 if (RaColorAlgorithms[i] != NULL)
6019 RaColorAlgorithms[i](parser, ns, cols, pair, attr);
6020
6021 return (retn);
6022 }
6023 #endif
6024 #endif
6025