lib/kcore/statistics.c

Go to the documentation of this file.

/*
 * $Id$
 *
 * Copyright (C) 2006 Voice Sistem SRL
 *
 * This file is part of Kamailio, a free SIP server.
 *
 * Kamailio is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Kamailio is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 *
 * History:
 * ---------
 *  2006-01-16  first version (bogdan)
 *  2006-11-28  added get_stat_var_from_num_code() (Jeffrey Magder -
 *              SOMA Networks)
 *  2010-08-08  removed all the parts emulated by kstats_wrapper.[ch] (andrei)
 */

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#include "../../ut.h"
#include "../../dprint.h"
#include "../../socket_info.h"
#include "statistics.h"

#ifdef STATISTICS


stat_var *get_stat_var_from_num_code(unsigned int numerical_code, int out_codes)
{
        static char msg_code[INT2STR_MAX_LEN+4];
        str stat_name;

        stat_name.s = int2bstr( (unsigned long)numerical_code, msg_code, 
                &stat_name.len);
        stat_name.s[stat_name.len++] = '_';

        if (out_codes) {
                stat_name.s[stat_name.len++] = 'o';
                stat_name.s[stat_name.len++] = 'u';
                stat_name.s[stat_name.len++] = 't';
        } else {
                stat_name.s[stat_name.len++] = 'i';
                stat_name.s[stat_name.len++] = 'n';
        }

        return get_stat(&stat_name);
}


#endif /*STATISTICS*/

#define MAX_PROC_BUFFER 256

int get_socket_list_from_proto(int **ipList, int protocol) {

        struct socket_info  *si;
        struct socket_info** list;

        int num_ip_octets   = 4;
        int numberOfSockets = 0;
        int currentRow      = 0;

        /* I hate to use #ifdefs, but this is necessary because of the way 
         * get_sock_info_list() is defined.  */
#ifndef USE_TCP
        if (protocol == PROTO_TCP) 
        {
                return 0;
        }
#endif

#ifndef USE_TLS
        if (protocol == PROTO_TLS)
        {
                return 0;
        }
#endif

        /* Retrieve the list of sockets with respect to the given protocol. */
        list=get_sock_info_list(protocol);

        /* Find out how many sockets are in the list.  We need to know this so
         * we can malloc an array to assign to ipList. */
        for(si=list?*list:0; si; si=si->next){
                /* We only support IPV4 at this point. */
                if (si->address.af == AF_INET) {
                        numberOfSockets++;
                }
        }

        /* There are no open sockets with respect to the given protocol. */
        if (numberOfSockets == 0)
        {
                return 0;
        }

        *ipList = pkg_malloc(numberOfSockets * (num_ip_octets + 1) * sizeof(int));

        /* We couldn't allocate memory for the IP List.  So all we can do is
         * fail. */
        if (*ipList == NULL) {
                LM_ERR("no more pkg memory");
                return 0;
        }


        /* We need to search the list again.  So find the front of the list. */
        list=get_sock_info_list(protocol);

        /* Extract out the IP Addresses and ports.  */
        for(si=list?*list:0; si; si=si->next){

                /* We currently only support IPV4. */
                if (si->address.af != AF_INET) {
                        continue;
                }

                (*ipList)[currentRow*(num_ip_octets + 1)  ] = 
                        si->address.u.addr[0];
                (*ipList)[currentRow*(num_ip_octets + 1)+1] = 
                        si->address.u.addr[1];
                (*ipList)[currentRow*(num_ip_octets + 1)+2] = 
                        si->address.u.addr[2];
                (*ipList)[currentRow*(num_ip_octets + 1)+3] = 
                        si->address.u.addr[3];
                (*ipList)[currentRow*(num_ip_octets + 1)+4] = 
                        si->port_no;
                
                currentRow++;
        }

        return numberOfSockets;
}

static int parse_proc_net_line(char *line, int *ipAddress, int *rx_queue) 
{
        int i;

        int ipOctetExtractionMask = 0xFF;

        char *currColonLocation;
        char *nextNonNumericalChar;
        char *currentLocationInLine = line;

        int parsedInteger[4];

        /* Example line from /proc/net/tcp or /proc/net/udp:
         *
         *      sl  local_address rem_address   st tx_queue rx_queue  
         *      21: 5A0A0B0A:CAC7 1C016E0A:0016 01 00000000:00000000
         *
         * Algorithm:
         *
         *      1) Find the location of the first  ':'
         *      2) Parse out the IP Address into an integer
         *      3) Find the location of the second ':'
         *      4) Parse out the port number.
         *      5) Find the location of the fourth ':'
         *      6) Parse out the rx_queue.
         */

        for (i = 0; i < 4; i++) {

                currColonLocation = strchr(currentLocationInLine, ':'); 

                /* We didn't find all the needed ':', so fail. */
                if (currColonLocation == NULL) {
                        return 0;
                }

                /* Parse out the integer, keeping the location of the next 
                 * non-numerical character.  */
                parsedInteger[i] = 
                        (int) strtol(++currColonLocation, &nextNonNumericalChar,
                                        16);

                /* strtol()'s specifications specify that the second parameter
                 * is set to the first parameter when a number couldn't be
                 * parsed out.  This means the parse was unsuccesful.  */
                if (nextNonNumericalChar == currColonLocation) {
                        return 0;
                }
                
                /* Reset the currentLocationInLine to the last non-numerical 
                 * character, so that next iteration of this loop, we can find
                 * the next colon location. */
                currentLocationInLine = nextNonNumericalChar;

        }

        /* Extract out the segments of the IP Address.  They are stored in
         * reverse network byte order. */
        for (i = 0; i < NUM_IP_OCTETS; i++) {
                
                ipAddress[i] = 
                        parsedInteger[0] & (ipOctetExtractionMask << i*8); 

                ipAddress[i] >>= i*8;

        }

        ipAddress[NUM_IP_OCTETS] = parsedInteger[1];

        *rx_queue = parsedInteger[3];
        
        return 1;
 
}


static int match_ip_and_port(int *ipOne, int *ipArray, int sizeOf_ipArray) 
{
        int curIPAddrIdx;
        int curOctetIdx;
        int ipArrayIndex;

        /* Loop over every IP Address */
        for (curIPAddrIdx = 0; curIPAddrIdx < sizeOf_ipArray; curIPAddrIdx++) {

                /* Check for octets that don't match.  If one is found, skip the
                 * rest.  */
                for (curOctetIdx = 0; curOctetIdx < NUM_IP_OCTETS + 1; curOctetIdx++) {
                        
                        /* We've encoded a 2D array as a 1D array.  So find out
                         * our position in the 1D array. */
                        ipArrayIndex = 
                                curIPAddrIdx * (NUM_IP_OCTETS + 1) + curOctetIdx;

                        if (ipOne[curOctetIdx] != ipArray[ipArrayIndex]) {
                                break;
                        }
                }

                /* If the index from the inner loop is equal to NUM_IP_OCTETS
                 * + 1, then that means that every octet (and the port with the
                 * + 1) matched. */
                if (curOctetIdx == NUM_IP_OCTETS + 1) {
                        return 1;
                }

        }

        return 0;
}


static int get_used_waiting_queue(
                int forTCP, int *interfaceList, int listSize) 
{
        FILE *fp;
        char *fileToOpen;
        
        char lineBuffer[MAX_PROC_BUFFER];
        int  ipAddress[NUM_IP_OCTETS+1];
        int  rx_queue;
        
        int  waitingQueueSize = 0;

        /* Set up the file we want to open. */
        if (forTCP) {
                fileToOpen = "/proc/net/tcp";
        } else {
                fileToOpen = "/proc/net/udp";
        }
        
        fp = fopen(fileToOpen, "r");

        if (fp == NULL) {
                LM_ERR("Could not open %s. openserMsgQueu eDepth and its related"
                                " alarms will not be available.\n", fileToOpen);
                return 0;
        }

        /* Read in every line of the file, parse out the ip address, port, and
         * rx_queue, and compare to our list of interfaces we are listening on.
         * Add up rx_queue for those lines which match our known interfaces. */
        while (fgets(lineBuffer, MAX_PROC_BUFFER, fp)!=NULL) {

                /* Parse out the ip address, port, and rx_queue. */
                if(parse_proc_net_line(lineBuffer, ipAddress, &rx_queue)) {

                        /* Only add rx_queue if the line just parsed corresponds 
                         * to an interface we are listening on.  We do this
                         * check because it is possible that this system has
                         * other network interfaces that OpenSER has been told
                         * to ignore. */
                        if (match_ip_and_port(ipAddress, interfaceList, listSize)) {
                                waitingQueueSize += rx_queue;
                        }
                }
        }

        fclose(fp);

        return waitingQueueSize;
}

int get_total_bytes_waiting(void) 
{
        int bytesWaiting = 0;

        int *UDPList  = NULL;
        int *TCPList  = NULL;
        int *TLSList  = NULL;

        int numUDPSockets  = 0;
        int numTCPSockets  = 0; 
        int numTLSSockets  = 0;

        /* Extract out the IP address address for UDP, TCP, and TLS, keeping
         * track of the number of IP addresses from each transport  */
        numUDPSockets  = get_socket_list_from_proto(&UDPList,  PROTO_UDP);
        numTCPSockets  = get_socket_list_from_proto(&TCPList,  PROTO_TCP);
        numTLSSockets  = get_socket_list_from_proto(&TLSList,  PROTO_TLS);

        /* Find out the number of bytes waiting on our interface list over all
         * UDP and TCP transports. */
        bytesWaiting  += get_used_waiting_queue(0, UDPList,  numUDPSockets);
        bytesWaiting  += get_used_waiting_queue(1, TCPList,  numTCPSockets);
        bytesWaiting  += get_used_waiting_queue(1, TLSList,  numTLSSockets);

        /* get_socket_list_from_proto() allocated a chunk of memory, so we need
         * to free it. */
        if (numUDPSockets > 0)
        {
                pkg_free(UDPList);
        }

        if (numTCPSockets > 0) 
        {
                pkg_free(TCPList);
        }

        if (numTLSSockets > 0)
        {
                pkg_free(TLSList);
        }

        return bytesWaiting;
}