/home/fernape/Projects/lkmonitor/src/others.c

Go to the documentation of this file.

/*
        lkmonitor (Linux Kernel Monitor)

        Application for monitoring and tuning a Linux kernel.

        Copyright (C) 2005-2008  Fernando Apesteguía

        This program 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.

        This program 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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
*/

#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include <gnome.h>
#include <string.h>
#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>
#include <glib.h>
#include <pthread.h>
#include <gtk/gtk.h>

#include "lininfo.h"
#include "processes.h"

int numsort(const void *stra,const void *strb)
{
        int a,b;
        a=atoi(stra);
        b=atoi(strb);
        
        
        return(a<b?(-1):(a==b?0:1));

}

int read_values_from_file(int parm,char *path, ...)
{
        g_assert(parm!=0 && path!=NULL);
        
        int i;
        int *val;
        va_list list;
        gchar *contents;
        char *p;
        
        if(g_file_get_contents((gchar *)path,&contents,NULL,NULL)==FALSE){
                va_start(list,path);
                for(i=0; i<parm;i++){
                        val=va_arg(list, int *);
                        *val=-1;
                }
                va_end(list);
                g_warning("Failed to open %s file",path);
                return -1;
        }
        
        p=contents;
        
        va_start(list,path);
        for(i=0; i<parm;i++){
                sscanf(p,"%d",va_arg(list, int *));
                p=strchr(p,'\t')+1;
        }
        va_end(list);
        
        g_free(contents);
        return(0);
}

int write_values_to_file(int parm, char *path,...)
{
        g_assert(parm!=0 && path!=NULL);
        
        int i;
        va_list list;
        FILE *target;
        gchar num_trans[15]; //Large enough
        GString *ms;
        
        ms=g_string_new("");
        
        if((target=fopen(path,"w"))==NULL){
                g_warning("Can't write to %s\n",path);
                return(-1);
        }
        
        /* File is ready to be written */

        va_start(list,path);
        for(i=0;i<parm;i++){
                sprintf(num_trans,"%d",va_arg(list,int));
                g_string_append(ms,num_trans);
                g_string_append(ms," ");
        }
        va_end(list);

        /* Write */
        fprintf(target,"%s",ms->str);
        fclose(target);
        return(0);
}

int write_string_to_file(const char *str,char *path)
{
  g_assert(str!=NULL && path!=NULL);
        
  FILE *f;
  
  if((f=fopen(path,"w"))==NULL){
          g_warning("Couldn't open file %s",path);
          return -1;
  }
  
  fprintf(f,"%s",str);
  fclose(f);
  
  return(0);
}


char *
trim (char *str)
{
  g_assert(str!=NULL);
  return (str + strspn (str, " "));
}                               


char *
rtrim(char* str)
{
        g_assert(str!=NULL);
        
        char* p;
        if((p=rindex(str,' '))==NULL)
                return(str);
        while(p>str){
                if(*p==' '){
                        *p='\0';
                        p--;
                }
                else return(str);
        }
        return(str);//For gcc warning   
}

char *
skip_lines (char* contents, int num_lines)
{
  g_assert(contents!=NULL && num_lines>=0);
        
  int i, c;

  for (i = 0; i < num_lines; c++){
    if (*contents=='\n')
      i++;

    contents++;
        
  }

  return (contents+1);
}

void
find_data_for (const char* pattern,char* member, const char* contents)
{       
   #define TAM 45
        g_assert(pattern!=NULL && member!=NULL && contents!=NULL);
        
        char p[TAM];
        char *line;
        
        sscanf(pattern,"%[^\t:]",p);
        //p has the name of the attribute (model, model name...)
        //strncpy(p,rtrim(p),TAM);
        rtrim(p);
        if((line=strstr(contents,p))==NULL){
                strncpy(member,_("Unknown"),strlen(_("Unknown")));
                *(member+strlen(_("Unknown")))='\0';
                return;
        }//Position in the correct line

        sscanf(line, pattern,member);
        
}                               

char *parse_batt(const char *str,char *contents, char *dest)
{

        g_assert(str!=NULL && contents!=NULL);
        
        char data[10];
        char *p;
        
        p=strstr(contents,str);
        if(p==NULL){
                return(_("Unknown"));
        }
        p=strstr(p,":")+1;
        sscanf(p,"%s",data);
        strncpy(dest,data,sizeof(dest));

        return dest;
}

gint list_com(gconstpointer a,gconstpointer b)
{
        struct lnode *la,*lb;
        
        la=(struct lnode *)a;
        lb=(struct lnode *)b;
        
        if(la->pid==lb->pid)
                return 0;
        
        return -1;
}

---