Return to stroke_counter.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / src / libcharon / plugins / stroke

Annotation of embedaddon/strongswan/src/libcharon/plugins/stroke/stroke_counter.c, revision 1.1

1.1     ! misho       1: /*
        !             2:  * Copyright (C) 2017 Tobias Brunner
        !             3:  * HSR Hochschule fuer Technik Rapperswil
        !             4:  *
        !             5:  * Copyright (C) 2012 Martin Willi
        !             6:  * Copyright (C) 2012 revosec AG
        !             7:  *
        !             8:  * This program is free software; you can redistribute it and/or modify it
        !             9:  * under the terms of the GNU General Public License as published by the
        !            10:  * Free Software Foundation; either version 2 of the License, or (at your
        !            11:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
        !            12:  *
        !            13:  * This program is distributed in the hope that it will be useful, but
        !            14:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
        !            15:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
        !            16:  * for more details.
        !            17:  */
        !            18: 
        !            19: #include <inttypes.h>
        !            20: 
        !            21: #include "stroke_counter.h"
        !            22: 
        !            23: #include <counters_query.h>
        !            24: 
        !            25: ENUM(stroke_counter_type_names,
        !            26:        COUNTER_INIT_IKE_SA_REKEY, COUNTER_OUT_INFORMATIONAL_RSP,
        !            27:        "ikeInitRekey",
        !            28:        "ikeRspRekey",
        !            29:        "ikeChildSaRekey",
        !            30:        "ikeInInvalid",
        !            31:        "ikeInInvalidSpi",
        !            32:        "ikeInInitReq",
        !            33:        "ikeInInitRsp",
        !            34:        "ikeOutInitReq",
        !            35:        "ikeOutInitRsp",
        !            36:        "ikeInAuthReq",
        !            37:        "ikeInAuthRsp",
        !            38:        "ikeOutAuthReq",
        !            39:        "ikeOutAuthRsp",
        !            40:        "ikeInCrChildReq",
        !            41:        "ikeInCrChildRsp",
        !            42:        "ikeOutCrChildReq",
        !            43:        "ikeOutCrChildRsp",
        !            44:        "ikeInInfoReq",
        !            45:        "ikeInInfoRsp",
        !            46:        "ikeOutInfoReq",
        !            47:        "ikeOutInfoRsp",
        !            48: );
        !            49: 
        !            50: typedef struct private_stroke_counter_t private_stroke_counter_t;
        !            51: 
        !            52: /**
        !            53:  * Private data of an stroke_counter_t object.
        !            54:  */
        !            55: struct private_stroke_counter_t {
        !            56: 
        !            57:        /**
        !            58:         * Public stroke_counter_t interface.
        !            59:         */
        !            60:        stroke_counter_t public;
        !            61: 
        !            62:        /**
        !            63:         * Reference to query interface
        !            64:         */
        !            65:        counters_query_t *query;
        !            66: };
        !            67: 
        !            68: /**
        !            69:  * Make sure we have the query interface
        !            70:  */
        !            71: static inline bool ensure_query(private_stroke_counter_t *this)
        !            72: {
        !            73:        if (this->query)
        !            74:        {
        !            75:                return TRUE;
        !            76:        }
        !            77:        return (this->query = lib->get(lib, "counters")) != NULL;
        !            78: }
        !            79: 
        !            80: /**
        !            81:  * Print global or connection-specific IKE counters
        !            82:  */
        !            83: static void print_one(private_stroke_counter_t *this, FILE *out, char *name)
        !            84: {
        !            85:        uint64_t *counters;
        !            86:        counter_type_t i;
        !            87: 
        !            88:        counters = this->query->get_all(this->query, name);
        !            89:        if (!counters)
        !            90:        {
        !            91:                fprintf(out, "No IKE counters found for '%s'\n", name);
        !            92:                return;
        !            93:        }
        !            94:        if (name)
        !            95:        {
        !            96:                fprintf(out, "\nList of IKE counters for '%s':\n\n", name);
        !            97:        }
        !            98:        else
        !            99:        {
        !           100:                fprintf(out, "\nList of IKE counters:\n\n");
        !           101:        }
        !           102:        for (i = 0; i < COUNTER_MAX; i++)
        !           103:        {
        !           104:                fprintf(out, "%-18N %12"PRIu64"\n", stroke_counter_type_names, i,
        !           105:                                counters[i]);
        !           106:        }
        !           107:        free(counters);
        !           108: }
        !           109: 
        !           110: /**
        !           111:  * Print counters for all connections
        !           112:  */
        !           113: static void print_all(private_stroke_counter_t *this, FILE *out)
        !           114: {
        !           115:        enumerator_t *enumerator;
        !           116:        char *name;
        !           117: 
        !           118:        enumerator = this->query->get_names(this->query);
        !           119:        while (enumerator->enumerate(enumerator, &name))
        !           120:        {
        !           121:                print_one(this, out, name);
        !           122:        }
        !           123:        enumerator->destroy(enumerator);
        !           124: }
        !           125: 
        !           126: METHOD(stroke_counter_t, print, void,
        !           127:        private_stroke_counter_t *this, FILE *out, char *name)
        !           128: {
        !           129:        if (!ensure_query(this))
        !           130:        {
        !           131:                fprintf(out, "\nNo counters available (plugin missing?)\n\n");
        !           132:                return;
        !           133:        }
        !           134:        if (name && streq(name, "all"))
        !           135:        {
        !           136:                return print_all(this, out);
        !           137:        }
        !           138:        return print_one(this, out, name);
        !           139: }
        !           140: 
        !           141: METHOD(stroke_counter_t, reset, void,
        !           142:        private_stroke_counter_t *this, char *name)
        !           143: {
        !           144:        if (!ensure_query(this))
        !           145:        {
        !           146:                return;
        !           147:        }
        !           148:        this->query->reset(this->query, name);
        !           149: }
        !           150: 
        !           151: METHOD(stroke_counter_t, destroy, void,
        !           152:        private_stroke_counter_t *this)
        !           153: {
        !           154:        free(this);
        !           155: }
        !           156: 
        !           157: /**
        !           158:  * See header
        !           159:  */
        !           160: stroke_counter_t *stroke_counter_create()
        !           161: {
        !           162:        private_stroke_counter_t *this;
        !           163: 
        !           164:        INIT(this,
        !           165:                .public = {
        !           166:                        .print = _print,
        !           167:                        .reset = _reset,
        !           168:                        .destroy = _destroy,
        !           169:                },
        !           170:        );
        !           171: 
        !           172:        return &this->public;
        !           173: }