asdf

/* Kevin Jafari
** Assignment 1 Operating Systems Design
** September 29, 2010
** This program has 10 functions that compute the following:
**  -CPU type and model
**  -Kernel version
**  -Amount of time since the system was last booted, in the form dd:hh:mm:ss
**  -The amount of time that the CPU has spent in user mode, in system mode, and idle.
**  -The number of disk requests made on the system.
**  -The number of context switches that the kernel has performed.
**  -The time when the system was last booted.
**  -The number of processes that have been created since the system was booted.
**  -The amount of memory configured into this computer.
**  -The amount of memory currently available.
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <sys/utsname.h>
#include <time.h>
#include <syslog.h>
#define USER_INPUT_SIZE 5
#define ROW_SIZE 150

char* cpumodel();
char* kernelver();
char* boottimer();


int main()
{
    openlog("prog1", 0, LOG_USER);

    char *str = (char *) malloc(sizeof(char)*250);

    //#1
    str = cpumodel();
    printf("Cpu model and type: %s\n", str);
    syslog(LOG_INFO, "Cpu model and type: %s", str);

    //#2
    str = kernelver();
    printf("Kernel version: %s\n", str);
    syslog(LOG_INFO, "Kernel version: %s", str);

    //str =
    boottimer();
    //printf("%s", str);

    /*//
    /*
    //#4
    FILE *fp;
    if ((fp = fopen("/proc/stat", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/stat: %s", strerror(errno));
        return 1;
    }

    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    row = fgets(row, ROW_SIZE, fp);

    row = strtok(row, " ");
    char *normpromode;
    char *nicepromode;
    char *sysmode;
    char *idle;

    char *strtoulPtr;
    int normtime, nicetime;

    if ( row != NULL )
    {
        normpromode = strtok(NULL, " ");

        if ( normpromode != NULL)
        {
            nicepromode = strtok(NULL, " ");

            if ( nicepromode != NULL)
            {
                sysmode = strtok(NULL, " ");

                if ( sysmode != NULL)
                {
                    idle = strtok(NULL, " ");

                    if ( idle != NULL )
                    {
                        normtime = strtoul(normpromode, strtoulPtr, 10);
                        nicetime = strtoul(nicepromode, strtoulPtr, 10);

                        printf("CPU Times:\nUser mode: %d\nSystem mode: %s\nIdle: %s", (normtime + nicetime), sysmode, idle);
                    }
                    else
                    {
                        fprintf(stderr, "Error retrieving idle time info from /proc/stat.");
                        return 1;
                    }
                }
                else
                {
                    fprintf(stderr, "Error retrieving system process time info from /proc/stat.");
                    return 1;
                }
            }
            else
            {
                fprintf(stderr, "Error retrieving niced process time info from /proc/stat.");
                return 1;
            }
        }
        else
        {
            fprintf(stderr, "Error retrieving normal process time info from /proc/stat.");
            return 1;
        }
    }
    else
    {
        fprintf(stderr, "Error retrieving cpu info from /proc/stat.");
        return 1;
    }

    fclose(fp);
    free(row);
    */
    /*
    //#5
    FILE *fp;
    if ((fp = fopen("/sys/block/sda/stat", "r")) == NULL)
    {
        fprintf(stderr, "Error opening /sys/block/sda/stat: %s", strerror(errno));
        return 1;
    }

    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    row = fgets(row, ROW_SIZE, fp);

    char *read, *written, *readmerge, *writtenmerge, *readsec, *writtensec, *current, *strtoulPtr;
    int readint, writtenint, readmergeint, writtenmergeint, readsecint, writtensecint, currentint;

    row = strtok(row, " ");

    int cnt=1;
    while( row != NULL )
    {
        switch(cnt)
        {
            case 1:
                read = row;
                break;
            case 2:
                readmerge = row;
                break;
            case 3:
                readsec = row;
                break;
            case 5:
                written = row;
                break;
            case 6:
                writtenmerge = row;
                break;
            case 7:
                writtensec = row;
                break;
            case 9:
                current = row;
                break;
        }
        row = strtok(NULL, " ");
        cnt++;

    }

    if (read == NULL ||
            readmerge == NULL ||
            readsec == NULL ||
            written == NULL ||
            writtenmerge == NULL ||
            writtensec == NULL ||
            current == NULL)
    {
        fprintf(stderr, "Error retrieving disk info from /sys/block/sda/stat.");
        return 1;
    }

    readint = strtoul(read, strtoulPtr, 10);
    readmergeint = strtoul(readmerge, strtoulPtr, 10);
    readsecint = strtoul(readsec, strtoulPtr, 10);
    writtenint = strtoul(written, strtoulPtr, 10);
    writtenmergeint = strtoul(writtenmerge, strtoulPtr, 10);
    writtensecint = strtoul(writtensec, strtoulPtr, 10);
    currentint = strtoul(current, strtoulPtr, 10);

    printf("read: %d\nreadmerge: %d\nreadsec: %d\nwritten %d\nwrittenmerge: %d\nwrittensec: %d\ncurrent: %d\n",
        readint, readmergeint, readsecint, writtenint, writtenmergeint, writtensecint, currentint);

    printf("_____________________\n");
    printf("Total disk read/writen: %d\n", (readint+writtenint+currentint-readmergeint-writtenmergeint));
    printf("Total disk sectors read/written : %d\n", (readsecint+writtensecint));

    fclose(fp);
    free(row);
    */
    /*//6
    FILE *fp;
    if ((fp = fopen("/proc/stat", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/stat: %s", strerror(errno));
        return 1;
    }

    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    row = fgets(row, ROW_SIZE, fp);

    char *pattern = "ctxt";

    while(!feof(fp))
    {
        row = fgets(row, ROW_SIZE, fp);

        if(strstr(row, pattern))
        {
            break;
        }
    }

    row = strtok(row, " ");


    if ( row != NULL)
    {
        row = strtok(NULL," ");
    }
    else
    {
        fprintf(stderr, "Error reading context switches from /proc/stat: %s");
        return 1;
    }

    printf("Number of context switches: %s\n",row);

    fclose(fp);
    //free(row);
    */
    /*
    //#7
    FILE *fp;
    if ((fp = fopen("/proc/uptime", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/uptime: %s", strerror(errno));
        return 1;
    }
    char *row = (char*)malloc(250*sizeof(char));

    row = fgets(row, 250, fp);

    row = strtok(row, " ");

    char *strtoulPtr;

    int timer = strtoul(row, &strtoulPtr, 10);

    time_t totaltime = time(NULL) ;//- timer;

    printf("Time when system was booted:\n%s", asctime(localtime(&totaltime)));

    fclose(fp);
    free(row);
    */
    /*
    //8
    FILE *fp;
    if ((fp = fopen("/proc/stat", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/stat: %s", strerror(errno));
        return 1;
    }

    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    row = fgets(row, ROW_SIZE, fp);

    char *pattern = "processes";

    while(!feof(fp))
    {
        row = fgets(row, ROW_SIZE, fp);

        if(strstr(row, pattern))
        {
            break;
        }

    }

    row = strtok(row, " ");


    if ( row != NULL)
    {
        row = strtok(NULL," ");
    }
    else
    {
        fprintf(stderr, "Error reading processes from /proc/stat: %s");
        return 1;
    }

    printf("Number of processes since system was booted: %s\n",row);

    fclose(fp);
    //free(row);
    */
    /*//9

    FILE *fp;
    if ((fp = fopen("/proc/meminfo", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/meminfo: %s", strerror(errno));
        return 1;
    }
    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    char *pattern = "MemTotal", *strtoulPtr;


    while(!feof(fp))
    {
        row = fgets(row, ROW_SIZE, fp);

        if(strstr(row, pattern))
        {
            break;
        }

    }

    char *extract = strstr(row,": ");

    extract += 1;

    int memnum = strtoul(extract, strtoulPtr, 10);

    printf("Total system memory is: %d kB\n", memnum);

    fclose(fp);
    free(row);

    /*
    //10
    FILE *fp;
    if ((fp = fopen("/proc/meminfo", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/meminfo: %s", strerror(errno));
        return 1;
    }
    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    char *pattern = "MemFree", *strtoulPtr;


    while(!feof(fp))
    {
        row = fgets(row, ROW_SIZE, fp);

        if(strstr(row, pattern))
        {
            break;
        }
    }

    char *extract = strstr(row,": ");

    extract += 1;

    int memnum = strtoul(extract, strtoulPtr, 10);

    printf("Available memory is: %d kB\n", memnum);

    fclose(fp);
    free(row);
    */

    return 0;
}

char* cpumodel() //#1
{

    FILE *fp;
    if ((fp = fopen("/proc/cpuinfo", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/cpuinfo: %s", strerror(errno));
        return NULL;
        //
    }

    char *row = (char*)malloc(ROW_SIZE*sizeof(char));
    char *pattern = "model name";

    while(!feof(fp))
    {
        row = fgets(row, ROW_SIZE, fp);

        if(strstr(row, pattern))
        {
            break;
        }
    }

    char *extract = strstr(row,": ");
    extract += 2;

    fclose(fp);

    return extract;
}

char* kernelver()
{
    struct utsname kernel;

    int struDis = uname (&kernel);

    if (struDis == -1)
    {
        fprintf(stderr, "Error using uname function: %s", strerror(errno));
        return NULL;
    }

    char *returnStr = (char *) malloc(sizeof(char)*strlen(kernel.version+1));

    strcpy(returnStr, kernel.version);

    return (returnStr);
}

char* boottimer()
{
    FILE *fp;
    if ((fp = fopen("/proc/uptime", "r")) ==NULL)
    {
        fprintf(stderr, "Error opening /proc/uptime: %s", strerror(errno));
        return 1;
    }
    char *row = (char*)malloc(250*sizeof(char));

    row = fgets(row, 250, fp);

    row = strtok(row, " ");

    char *strtoulPtr;

    int time = strtoul(row, &strtoulPtr, 10);

    int dd, hh, mm, ss = time;
    dd = ss /86400; //how many seconds in a day
    ss -=  dd*86400;
    hh = ss /3600;  //how many seconds in an hour
    ss -= hh*3600;
    mm = ss / 60;
    ss -= mm *60;

    //printf("Amount of time since system was booted: (%02dd, %02dh, %02dm, %02ds) ", dd, hh, mm, ss);

    char *returnStr = (char *) malloc(sizeof(char)*(100));

    strcpy(returnStr, ("Amount of time since system was booted: (%02dd, %02dh, %02dm, %02ds) ", dd, hh, mm, ss) );

    //printf("here %s\n", returnStr);
    //printf("here\n");
    //strcpy(returnStr, returnStr);
    //printf("here\n");
    fclose(fp);

    return "hello";

}