FILE *mtab;
mtab=fopen("/etc/mtab","r");
if (mtab == NULL) {
      printf("Cant read /etc/mtab\n");
      exit(1);
}
char line[200];

while( fgets(line, sizeof(line), mtab) != NULL ) {
      printf("%s",line):
}
fclose(mtab);

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <glib-2.0/glib.h>
#include <dbus-1.0/dbus/dbus.h>
#include <hal/libhal.h>

#define CR 13
#define LF 10

struct mountpoint
{
   char *blockdevice;
   char *mountplace;
};

int main(void)
{
   //some required variables
   static LibHalContext *ctx;   
   DBusError error;
   DBusConnection *bus;
   char **devices;
   char *properties;
   int i_devices, i;
      
   //GMainLoop *main_loop;
   //GMainContext *g_context;
         
   //initialize the system   
   dbus_error_init(&error);
   bus=dbus_bus_get(DBUS_BUS_SYSTEM,&error);
   ctx = libhal_ctx_new();
   
   //Check if the bus and the context have been properly initialized
   if (dbus_error_is_set(&error))
   {
       g_warning("Could not connect to system bus %s\n", error.message);
    }
   
   if (!bus)
   {
      g_warning("Could not connect to system bus: %s\n",error.message);
      dbus_error_free(&error);
      return 1;
   }
      
   if (!ctx)
   {
      g_warning("Could not get context libhal_ctx_new()\n");
      return 1;
   }
   
   libhal_ctx_set_dbus_connection(ctx, bus);
   
   
   //Let's fetch all the devices (UDIs) for devices from the category "storage"
    if (!(devices = libhal_manager_find_device_string_match (ctx,"storage.drive_type","disk", &i_devices, &error))) {
      
       g_warning("Error: %s: %s\n",error.name,error.message);
      
       dbus_error_free(&error);
       libhal_ctx_shutdown (ctx, NULL);
       libhal_ctx_free (ctx);
       return 1;
       }
   
   for (i=0; i < i_devices; i++)
   {
      
      properties=libhal_device_get_property_string(ctx,devices[i],"block.device", &error);
      
      printf("%s:%s\n",devices[i],properties);
      
         
   }
   /*We happily open the mtab file */
   FILE *mtab;
   mtab=fopen("/etc/mtab","r");
   
   /*We get mtabs size to allocate the right ammount of memory*/
   int length;
   fseek(mtab,0,SEEK_END); //bounce to the end
   length = ftell(mtab);   //measure /////and add 1 for the first char (0)..
   fseek(mtab,0,SEEK_SET)   ;//bounce back to the beginning
      
   /*We allocate the right amount of memory*/
   char *storage = calloc(length,sizeof(char));
   
   /*And now we read the file into the storage char*/
   fread(storage,length,1,mtab);
   
   
   /*Output type 1: char-by-char with loop.
    * Good for seachrching for specific characters and counting lines
    * The idea might be to count lines and then see in which line
    * a given block device is in and only use that line.
    * I have to figure out how to create char arrays "on the fly" */
   
   char *position_pointer;
   position_pointer=storage;
   
   int line_count=0;         //USED:This baby will count the lines in a file
   int char_count=0;         //USED:
   int p;
   char *g;               //USED: compare to see if *g is  a \n (linefeed)
   char ** line_array;         //USED: This will hold the pointers to the strings of the lines
      
   //Here we count the amount of lines based on the \n (Linefeed) char
   for(g=strchr(storage, '\n');g!=NULL;g=strchr(g+1,'\n'))
   {
      line_count++;
   }
   
   line_array=(char **)malloc(sizeof(char *)*line_count);
   
   //We have to reset it to 0 since it will be used as the index of the array
   line_count=0;       
   
   char * position_pointer_2;
   
   position_pointer_2=position_pointer;
   
   /*Position_pointer_2 is the "back-track": the distance between position_pointer_2 and
    * position_pointer is the length of the string/line.
    * Position_pointer will slide to the end of a line (LF '\n') and then
    * copy everything between it and position_pointer_2 to a new string.
    * then position_pointer_2 will move to position_pointer+1 to be at the first character
    * _after_ the LF, hence in the new line. then the game will repeat.
    * The pointers to the strings will be stored in an array. The length
    * can be either calculated with strlen or with the pointers etc.
    * The proper amount of memory will be alloceted with malloc/calloc */
   
   //Here we (c)allocate the right amount of memory for the strings.
   
for(p=0;p<length;p++)
   {
      if(*position_pointer == LF)
      {
         if(line_count==0)
         {
            line_array[line_count]=calloc(p+1,sizeof(char));
            strncpy(line_array[line_count],position_pointer_2,p-char_count+1);
            //printf("line_array[%d] contains:%s",line_count,line_array[line_count]);
            printf("line_count:%d,p:%d,char_count:%d,length of string:%d\n",line_count,p,char_count,strlen(line_array[line_count]));
         }
         else
         {
            line_array[line_count]=calloc(p-char_count,sizeof(char));
            strncpy(line_array[line_count],position_pointer+1,p-char_count+1);
            //printf("line_array[%d] contains:%s",line_count,line_array[line_count]);
            printf("line_count:%d,p:%d,char_count:%d,length of string:%d\n",line_count,p,char_count,strlen(line_array[line_count]));
         }
         char_count=p;
         
         line_count++;
         
      }
      position_pointer++;
   }
   
      
   /*Output type 2: the whole string at one
    * Probably good for final output. Slightly uncontrolable.
    * Probably good to print stuff into file in the end with fprintf*/
   //printf("%s",storage);
   //fprintf(stdout,"%s",storage);
   
   
   free(line_array);   
   free(storage);
   fclose(mtab);
   
   
   //main_loop = g_main_loop_new(g_context,FALSE);
   //g_main_loop_run(main_loop);
   
   //Free all the variables
   dbus_error_free(&error);
   libhal_ctx_free(ctx);   
   return 0;
}