fltedit.c

一个很好用的linux 下的流量监控软件

                ftemp->next_entry = fe;
                ftemp->prev_entry = fe->prev_entry;

                /*
                 * Point firstvisible at new entry if we inserted at the
                 * top of the list.
                 */

                if (ftemp->prev_entry == NULL) {
                    fl->head = ftemp;
                    firstvisible = ftemp;
                } else
                    fe->prev_entry->next_entry = ftemp;

                fe->prev_entry = ftemp;
            }

            if (ftemp->next_entry == NULL)
                fl->tail = ftemp;

            fe = ftemp;
            update_hp_screen(fl, firstvisible, win);
            break;
        case 'a':
        case 'A':
        case 1:
            if (!new_hp_entry(&ftemp))
                break;

            gethostparams(&(ftemp->hp), "", "", "", "",
                          "", "", "", "", "I", "N", &gh_aborted);

            if (gh_aborted) {
                free(ftemp);
                continue;
            }

            /*
             * Add new node to the end of the list (or to the head if the
             * list is empty.
             */
            if (fl->tail != NULL) {
                fl->tail->next_entry = ftemp;
                ftemp->prev_entry = fl->tail;
            } else {
                fl->head = ftemp;
                fl->tail = ftemp;
                ftemp->prev_entry = ftemp->next_entry = NULL;
                firstvisible = fl->head;
                fe = ftemp;
                idx = 0;
            }

            ftemp->next_entry = NULL;
            fl->tail = ftemp;
            update_hp_screen(fl, firstvisible, win);
            break;
        case 'd':
        case 'D':
        case KEY_DC:
            if (fl->head != NULL) {
                /*
                 * Move firstvisible down if it's pointing to the target
                 * entry.
                 */

                if (firstvisible == fe)
                    firstvisible = fe->next_entry;

                /*
                 * Detach target node from list.
                 */
                if (fe->next_entry != NULL)
                    fe->next_entry->prev_entry = fe->prev_entry;
                else
                    fl->tail = fe->prev_entry;

                if (fe->prev_entry != NULL)
                    fe->prev_entry->next_entry = fe->next_entry;
                else
                    fl->head = fe->next_entry;

                /*
                 * Move pointer up if we're deleting the last entry.
                 * The list tail pointer has since been moved to the
                 * previous entry.
                 */
                if (fe->prev_entry == fl->tail) {
                    ftemp = fe->prev_entry;

                    /*
                     * Move screen pointer up. Really adjust the index if
                     * the pointer is anywhere below the top of the screen.
                     */
                    if (idx > 0)
                        idx--;
                    else {
                        /*
                         * Otherwise scroll the list down, and adjust the
                         * firstvisible pointer to point to the entry
                         * previous to the target.
                         */
                        if (ftemp != NULL) {
                            firstvisible = ftemp;
                        }
                    }
                } else
                    /*
                     * If we reach this point, we're deleting from before
                     * the tail of the list.  In that case, we point the
                     * screen pointer at the entry following the target.
                     */
                    ftemp = fe->next_entry;

                free(fe);
                fe = ftemp;
                update_hp_screen(fl, firstvisible, win);
            }
            break;
        case 13:
            if (fe != NULL) {
                sprintf(s_portstr1, "%u", fe->hp.sport1);
                sprintf(s_portstr2, "%u", fe->hp.sport2);
                sprintf(d_portstr1, "%u", fe->hp.dport1);
                sprintf(d_portstr2, "%u", fe->hp.dport2);
                inexstr[0] = toupper(fe->hp.reverse);
                inexstr[1] = '\0';
                matchop[0] = toupper(fe->hp.match_opposite);
                matchop[1] = '\0';

                gethostparams(&(fe->hp), fe->hp.s_fqdn, fe->hp.s_mask,
                              s_portstr1, s_portstr2, fe->hp.d_fqdn,
                              fe->hp.d_mask, d_portstr1, d_portstr2,
                              inexstr, matchop, &gh_aborted);

                update_hp_screen(fl, firstvisible, win);
            }

            break;
        case 'x':
        case 'X':
        case 'q':
        case 'Q':
        case 27:
        case 24:
            endloop_local = 1;
            break;
        case 'l':
        case 'L':
            tx_refresh_screen();
            break;
        }
        update_panels();
        doupdate();
    } while (!endloop_local);

    del_panel(panel);
    delwin(win);
    del_panel(bpanel);
    delwin(bwin);
    update_panels();
    doupdate();
}

/*
 * Remove a currently applied filter from memory
 */

void destroyfilter(struct filterlist *fl)
{
    struct filterent *fe;
    struct filterent *cfe;

    if (fl->head != NULL) {
        fe = fl->head;
        cfe = fl->head->next_entry;

        do {
            free(fe);
            fe = cfe;
            if (cfe != NULL)
                cfe = cfe->next_entry;
        } while (fe != NULL);

        fl->head = fl->tail = NULL;
    }
}


void definefilter(int *aborted)
{
    struct filterfileent ffile;
    char fntemp[14];
    struct filterlist fl;

    int pfd;
    int bw;
    int resp;

    /*
     * Lock facility
     */

    if (!mark_filter_change())
        return;

    get_filter_description(ffile.desc, aborted, "");

    if (*aborted) {
        clear_flt_tag();
        return;
    }
    genname(time((time_t *) NULL), fntemp);

    pfd =
        open(get_path(T_WORKDIR, fntemp), O_CREAT | O_WRONLY | O_TRUNC,
             S_IRUSR | S_IWUSR);
    if (pfd < 0) {
        tx_errbox("Cannot create filter data file", ANYKEY_MSG, &resp);
        *aborted = 1;
        clear_flt_tag();
        return;
    }

    close(pfd);

    pfd =
        open(OTHIPFLNAME, O_CREAT | O_WRONLY | O_APPEND,
             S_IRUSR | S_IWUSR);

    if (pfd < 0) {
        listfileerr(1);
        clear_flt_tag();
        return;
    }
    strcpy(ffile.filename, fntemp);
    bw = write(pfd, &ffile, sizeof(struct filterfileent));
    if (bw < 0)
        listfileerr(2);

    close(pfd);

    init_filter_table(&fl);
    modify_host_parameters(&fl);
    savefilter(get_path(T_WORKDIR, fntemp), &fl);
    destroyfilter(&fl);

    clear_flt_tag();
}

/*
 * Edit an existing filter
 */
void editfilter(int *aborted)
{
    char filename[FLT_FILENAME_MAX];
    struct filterlist fl;
    struct ffnode *flist;
    struct ffnode *ffile;
    struct filterfileent *ffe;

    if (!mark_filter_change())
        return;

    if (loadfilterlist(&flist) == 1) {
        listfileerr(1);
        destroyfilterlist(flist);
        clear_flt_tag();
        return;
    }
    pickafilter(flist, &ffile, aborted);

    clear_flt_tag();
    if ((*aborted)) {
        destroyfilterlist(flist);
        clear_flt_tag();
        return;
    }
    ffe = &(ffile->ffe);

    get_filter_description(ffe->desc, aborted, ffe->desc);

    if (*aborted) {
        destroyfilterlist(flist);
        clear_flt_tag();
        return;
    }
    strncpy(filename, get_path(T_WORKDIR, ffe->filename),
            FLT_FILENAME_MAX - 1);

    if (loadfilter(filename, &fl, FLT_DONTRESOLVE))
        return;

    modify_host_parameters(&fl);

    save_filterlist(flist);     /* This also destroys it */
    savefilter(filename, &fl);
    destroyfilter(&fl);
}

/*
 * Delete a filter record from the disk
 */

void delfilter(int *aborted)
{
    struct ffnode *fltfile;
    struct ffnode *fltlist;

    if (!mark_filter_change())
        return;

    if (loadfilterlist(&fltlist) == 1) {
        *aborted = 1;
        listfileerr(1);
        destroyfilterlist(fltlist);
        clear_flt_tag();
        return;
    }
    pickafilter(fltlist, &fltfile, aborted);

    if (*aborted) {
        clear_flt_tag();
        return;
    }
    unlink(get_path(T_WORKDIR, fltfile->ffe.filename));

    if (fltfile->prev_entry == NULL) {
        fltlist = fltlist->next_entry;
        if (fltlist != NULL)
            fltlist->prev_entry = NULL;
    } else {
        fltfile->prev_entry->next_entry = fltfile->next_entry;

        if (fltfile->next_entry != NULL)
            fltfile->next_entry->prev_entry = fltfile->prev_entry;
    }

    free(fltfile);

    save_filterlist(fltlist);
    clear_flt_tag();
    *aborted = 0;
}