Changeset 48 in MondoRescue for trunk/mondo/mondo/common/libmondo-mountlist.c


Ignore:
Timestamp:
Oct 6, 2005, 6:08:17 PM (19 years ago)
Author:
bcornec
Message:

asprintf + getline + memory management going on

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/mondo/mondo/common/libmondo-mountlist.c

    r30 r48  
    1 /* libmondo-mountlist.c                            subroutines for handling mountlist
    2    $Id: libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp $
    3 
    4 
    5 
    6 08/01
    7 - when evaluating mountlist, skip drive entirely if it does not exist
    8 
    9 07/14
    10 - always exclude /devpts, /proc, /sys from mountlist
    11    
    12 06/29/2004
    13 - changed some char[] to *char
    14 - drivelist is struct now, not char[][]
    15 
    16 10/19/2003
    17 - format_device() --- contract /dev/md/N to /dev/mdN to
    18   overcome devfs problems
    19 
    20 06/11
    21 - added support for 5th column in mountlist.txt, for labels
    22 
    23 05/08
    24 - added save_mountlist_to_disk() and load_mountlist()
    25   and misc other funcs from mondorestore.c
    26 
    27 05/05
    28 - added Joshua Oreman's FreeBSD patches
    29 
    30 04/24
    31 - added some assert()'s
    32 
    33 04/23
    34 - cleaned up evaluate_drive_within_mountlist() a bit
    35 
    36 01/15/2003
    37 - added code for LVM (Brian Borgeson)
    38 
    39 10/19/2002
    40 - added some comments
    41 
    42 07/24/2002
    43 - created
     1/* $Id$
     2subroutines for handling mountlist
    443*/
    45 
    464
    475/**
    … …  
    6119
    6220/*@unused@*/
    63 //static char cvsid[] = "$Id: libmondo-mountlist.c,v 1.2 2004/06/10 15:29:12 hugo Exp $";
     21//static char cvsid[] = "$Id$";
    6422
    6523/**
    … …  
    8543 * @see evaluate_mountlist
    8644 */
    87 int evaluate_drive_within_mountlist (struct mountlist_itself *mountlist,
    88                  char *drive, char *flaws_str)
     45int evaluate_drive_within_mountlist(struct mountlist_itself *mountlist,
     46                                    char *drive, char *flaws_str)
    8947#ifdef __FreeBSD__
    9048{
    9149// FreeBSD-specific version of evaluate_drive_within_mountlist()
    92     /*@ int **************************************************************/
    93   int prev_part_no = 0;
     50    /*@ int ************************************************************* */
     51    int prev_part_no = 0;
    9452    int curr_part_no = 0;
    9553    int pos = 0, npos = 0;
    … …  
    10260    int foundsome = FALSE;
    10361
    104     /*@ buffers *********************************************************/
    105   char tmp[MAX_STR_LEN];
    106     char device[MAX_STR_LEN];
    107     char mountpoint[MAX_STR_LEN];
    108 
    109     /*@ long ************************************************************/
    110   long physical_drive_size = 0;
     62    /*@ buffers ******************************************************** */
     63    char *tmp;
     64    char *device;
     65    // BERLIOS : useless ? char *mountpoint;
     66
     67    /*@ long *********************************************************** */
     68    long physical_drive_size = 0;
    11169    long amount_allocated = 0;
    11270
    113     /*@ pointers ********************************************************/
     71    /*@ pointers ******************************************************* */
    11472    char *part_table_fmt;
    11573
    116     /*@ initialize ******************************************************/
    117   flaws_str[0] = '\0';
    118   prev_part_no = 0;
    119   tmp[0] = '\0';
    120 
    121 
    122   physical_drive_size = get_phys_size_of_drive (drive);
    123 
    124   if (physical_drive_size < 0)
    125     {
    126       sprintf (tmp, " %s does not exist.", drive);
    127       strcat (flaws_str, tmp);
    128     }
    129   else
    130     {
    131       sprintf (tmp, "%s is %ld MB", drive, physical_drive_size);
    132     }
    133   log_it (tmp);
    134  
    135 
    136   /* check DD */
    137   for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
    138       sprintf (device, "%s%c", drive, cur_sp_no);
    139       if (find_device_in_mountlist (mountlist, device) >= 0)
    140       foundsome = TRUE;
    141   }
    142   if (foundsome) {
    143       for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {   
    144       sprintf (device, "%s%c", drive, cur_sp_no);
    145       pos = find_device_in_mountlist (mountlist, device);
    146       if (pos < 0)
    147           {
    148           continue;
    149           }
    150       strcpy (mountpoint, mountlist->el[pos].mountpoint);
    151       /* is it too big? */
    152       if (curr_part_no > 'h')
    153           {
    154           sprintf (tmp, " Can only have up to 'h' in disklabel.");
    155           log_it (tmp);
    156           strcat (flaws_str, tmp);
    157           res++;
    158           }
    159       /* does partition /dev/adXsYZ exist more than once in the mountlist? */
    160       for (i = 0, mountpoint_copies = 0, device_copies = 0;
    161            i < mountlist->entries; i++)
    162           {
    163           if (!strcmp (device, mountlist->el[i].device))
    164               {
    165               device_copies++;
    166               }
    167           }
    168       if (device_copies > 1)
    169           {
    170           sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
    171           if (!strstr (flaws_str, tmp))
    172               {
    173               log_it (tmp);
    174               strcat (flaws_str, tmp);
    175               res++;
    176               }
    177           }
    178       /* silly partition size? */
    179       if (mountlist->el[pos].size < 8192
    180           && strcmp (mountlist->el[pos].mountpoint, "lvm"))
    181           {
    182           sprintf (tmp, " %s is tiny!", device);
    183           log_it (tmp);
    184           strcat (flaws_str, tmp);
    185           res++;
    186           }
    187       /* mountpoint should begin with / unless it is swap, lvm or raid */
    188       if (strcmp (mountlist->el[pos].mountpoint, "swap")
    189           && strcmp (mountlist->el[pos].mountpoint, "lvm")
    190           && strcmp (mountlist->el[pos].mountpoint, "raid")
    191           && strcmp (mountlist->el[pos].mountpoint, "image")
    192           && strcmp (mountlist->el[pos].mountpoint, "none")
    193           && mountlist->el[pos].mountpoint[0] != '/')
    194           {
    195           sprintf (tmp, " %s has a weird mountpoint.", device);
    196           log_it (tmp);
    197           strcat (flaws_str, tmp);
    198           res++;
    199           }
    200       /* is format sensible? */
    201       if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
    202           {
    203           sprintf (tmp, " %s has unsupported format.", device);
    204           log_it (tmp);
    205           strcat (flaws_str, tmp);
    206           res++;
    207           }
    208       amount_allocated += mountlist->el[pos].size / 1024;
    209       prev_sp_no = cur_sp_no;
    210       }
    211   }
    212 
    213   npos = pos = 0;
    214   for (curr_part_no = 1; curr_part_no < 99; curr_part_no++)
    215     {
    216       sprintf (device, "%ss%d", drive, curr_part_no);
    217       pos = find_device_in_mountlist (mountlist, device);
    218       npos = 0;
    219       for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) {
    220       sprintf (device, "%ss%i%c", device, curr_part_no, cur_sp_no);
    221       if (find_device_in_mountlist (mountlist, device) >= 0) npos++;
    222       }
    223       if (((pos >= 0) || npos) && foundsome) {
    224       sprintf (flaws_str + strlen (flaws_str), " %s has both DD and PC-style partitions.", drive);
    225       return ++res; // fatal error
    226       }
    227      
    228       sprintf (device, "%ss%d", drive, curr_part_no);
    229       strcpy (mountpoint, mountlist->el[pos].mountpoint);
    230       if (pos > 0 && !npos) {
    231       /* gap in the partition list? */
    232       if (curr_part_no - prev_part_no > 1)
    233           {
    234           if (prev_part_no == 0)
    235               {
    236               sprintf (tmp, " Gap prior to %s.", device);
    237               log_it (tmp);
    238               strcat (flaws_str, tmp);
    239               res++;
    240               }
    241           else if (curr_part_no > 5
    242                || (curr_part_no <= 4 && prev_part_no > 0))
    243               {
    244               sprintf (tmp, " Gap between %ss%d and %d.", drive, prev_part_no,
    245                    curr_part_no);
    246               log_it (tmp);
    247               strcat (flaws_str, tmp);
    248               res++;
    249               }
    250           }
    251       /* GPT allows more than 4 primary partitions */
    252       part_table_fmt = which_partition_format(drive);
    253       /* no spare primary partitions to help accommodate the logical(s)? */
    254       if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0))
    255           {
    256           sprintf (tmp, " Partition %ss4 is occupied.", drive);
    257           log_it (tmp);
    258           strcat (flaws_str, tmp);
    259           res++;
    260           }
    261       /* does partition /dev/adXsY exist more than once in the mountlist? */
    262       for (i = 0, mountpoint_copies = 0, device_copies = 0;
    263            i < mountlist->entries; i++)
    264           {
    265           if (!strcmp (device, mountlist->el[i].device))
    266               {
    267               device_copies++;
    268               }
    269           }
    270       if (device_copies > 1)
    271           {
    272           sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
    273           if (!strstr (flaws_str, tmp))
    274               {
    275               log_it (tmp);
    276               strcat (flaws_str, tmp);
    277               res++;
    278               }
    279           }
    280       /* silly partition size? */
    281       if (mountlist->el[pos].size < 8192
    282           && strcmp (mountlist->el[pos].mountpoint, "lvm"))
    283           {
    284           sprintf (tmp, " %s is tiny!", device);
    285           log_it (tmp);
    286           strcat (flaws_str, tmp);
    287           res++;
    288           }
    289       /* mountpoint should begin with / unless it is swap, lvm or raid */
    290       if (strcmp (mountlist->el[pos].mountpoint, "swap")
    291           && strcmp (mountlist->el[pos].mountpoint, "lvm")
    292           && strcmp (mountlist->el[pos].mountpoint, "raid")
    293           && strcmp (mountlist->el[pos].mountpoint, "image")
    294           && strcmp (mountlist->el[pos].mountpoint, "none")
    295           && mountlist->el[pos].mountpoint[0] != '/')
    296           {
    297           sprintf (tmp, " %s has a weird mountpoint.", device);
    298           log_it (tmp);
    299           strcat (flaws_str, tmp);
    300           res++;
    301           }
    302       /* is format sensible? */
    303       if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
    304           {
    305           sprintf (tmp, " %s has unsupported format.", device);
    306           log_it (tmp);
    307           strcat (flaws_str, tmp);
    308           res++;
    309           }
    310       } else {
    311       /* Check subpartitions */
    312       for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {   
    313           sprintf (device, "%ss%d%c", drive, curr_part_no, cur_sp_no);
    314           pos = find_device_in_mountlist (mountlist, device);
    315           if (pos < 0)
    316           {
    317           continue;
    318           }
    319           strcpy (mountpoint, mountlist->el[pos].mountpoint);
    320           /* is it too big? */
    321           if (curr_part_no > 'h')
    322           {
    323               sprintf (tmp, " Can only have up to 'h' in disklabel.");
    324               log_it (tmp);
    325               strcat (flaws_str, tmp);
    326               res++;
    327           }
    328           /* does partition /dev/adXsYZ exist more than once in the mountlist? */
    329           for (i = 0, mountpoint_copies = 0, device_copies = 0;
    330            i < mountlist->entries; i++)
    331           {
    332               if (!strcmp (device, mountlist->el[i].device))
    333               {
    334                   device_copies++;
    335               }
    336           }
    337           if (device_copies > 1)
    338           {
    339               sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
    340               if (!strstr (flaws_str, tmp))
    341               {
    342                   log_it (tmp);
    343                   strcat (flaws_str, tmp);
    344                   res++;
    345               }
    346           }
    347           /* silly partition size? */
    348           if (mountlist->el[pos].size < 8192
    349           && strcmp (mountlist->el[pos].mountpoint, "lvm"))
    350           {
    351               sprintf (tmp, " %s is tiny!", device);
    352               log_it (tmp);
    353               strcat (flaws_str, tmp);
    354               res++;
    355           }
    356           /* mountpoint should begin with / unless it is swap, lvm or raid */
    357           if (strcmp (mountlist->el[pos].mountpoint, "swap")
    358           && strcmp (mountlist->el[pos].mountpoint, "lvm")
    359           && strcmp (mountlist->el[pos].mountpoint, "raid")
    360           && strcmp (mountlist->el[pos].mountpoint, "image")
    361           && strcmp (mountlist->el[pos].mountpoint, "none")
    362           && mountlist->el[pos].mountpoint[0] != '/')
    363           {
    364               sprintf (tmp, " %s has a weird mountpoint.", device);
    365               log_it (tmp);
    366               strcat (flaws_str, tmp);
    367               res++;
    368           }
    369           /* is format sensible? */
    370           if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
    371           {
    372               sprintf (tmp, " %s has unsupported format.", device);
    373               log_it (tmp);
    374               strcat (flaws_str, tmp);
    375               res++;
    376           }
    377           amount_allocated += mountlist->el[pos].size / 1024;
    378           prev_sp_no = cur_sp_no;
    379       }
    380       }
    381      
    382       /* OK, continue with main loop */
    383       amount_allocated += mountlist->el[pos].size / 1024;
    384       prev_part_no = curr_part_no;
    385     }
    386 
    387   /* Over-allocated the disk? Unallocated space on disk? */
    388   if (amount_allocated > physical_drive_size)  // Used to be +1, but what if you're 1 MB too high?
    389     {
    390       sprintf (tmp, " %ld MB over-allocated on %s.",
    391            amount_allocated - physical_drive_size, drive);
    392       log_it (tmp);
    393       strcat (flaws_str, tmp);
    394       res++;
    395     }
    396   else if (amount_allocated < physical_drive_size - 1)
    397     {               /* NOT AN ERROR, JUST A WARNING :-) */
    398       sprintf (tmp, " %ld MB unallocated on %s.",
    399            physical_drive_size - amount_allocated, drive);
    400       log_it (tmp), strcat (flaws_str, tmp);
    401     }
    402   if (res)
    403     {
    404       return (FALSE);
    405     }
    406   else
    407     {
    408       return (TRUE);
    409     }
     74    /*@ initialize ***************************************************** */
     75    flaws_str[0] = '\0';
     76    prev_part_no = 0;
     77    // BERLIOS: tmp[0] = '\0';
     78
     79
     80    physical_drive_size = get_phys_size_of_drive(drive);
     81
     82    if (physical_drive_size < 0) {
     83        asprintf(&tmp, " %s does not exist.", drive);
     84        strcat(flaws_str, tmp);
     85    } else {
     86        asprintf(&tmp, "%s is %ld MB", drive, physical_drive_size);
     87    }
     88    log_it(tmp);
     89    paranoid_free(tmp);
     90
     91
     92    /* check DD */
     93    for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
     94        asprintf(&device, "%s%c", drive, cur_sp_no);
     95        if (find_device_in_mountlist(mountlist, device) >= 0)
     96            foundsome = TRUE;
     97        paranoid_free(device);
     98    }
     99    if (foundsome) {
     100        for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
     101            asprintf(&device, "%s%c", drive, cur_sp_no);
     102            pos = find_device_in_mountlist(mountlist, device);
     103            if (pos < 0) {
     104                continue;
     105            }
     106            // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
     107            /* is it too big? */
     108            if (curr_part_no > 'h') {
     109                asprintf(&tmp, " Can only have up to 'h' in disklabel.");
     110                log_it(tmp);
     111                strcat(flaws_str, tmp);
     112                paranoid_free(tmp);
     113                res++;
     114            }
     115            /* does partition /dev/adXsYZ exist more than once in the mountlist? */
     116            for (i = 0, mountpoint_copies = 0, device_copies = 0;
     117                 i < mountlist->entries; i++) {
     118                if (!strcmp(device, mountlist->el[i].device)) {
     119                    device_copies++;
     120                }
     121            }
     122            if (device_copies > 1) {
     123                asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
     124                        device);
     125                if (!strstr(flaws_str, tmp)) {
     126                    log_it(tmp);
     127                    strcat(flaws_str, tmp);
     128                    res++;
     129                }
     130                paranoid_free(tmp);
     131            }
     132            /* silly partition size? */
     133            if (mountlist->el[pos].size < 8192
     134                && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
     135                asprintf(&tmp, " %s is tiny!", device);
     136                log_it(tmp);
     137                strcat(flaws_str, tmp);
     138                paranoid_free(tmp);
     139                res++;
     140            }
     141            /* mountpoint should begin with / unless it is swap, lvm or raid */
     142            if (strcmp(mountlist->el[pos].mountpoint, "swap")
     143                && strcmp(mountlist->el[pos].mountpoint, "lvm")
     144                && strcmp(mountlist->el[pos].mountpoint, "raid")
     145                && strcmp(mountlist->el[pos].mountpoint, "image")
     146                && strcmp(mountlist->el[pos].mountpoint, "none")
     147                && mountlist->el[pos].mountpoint[0] != '/') {
     148                asprintf(&tmp, " %s has a weird mountpoint.", device);
     149                log_it(tmp);
     150                strcat(flaws_str, tmp);
     151                paranoid_free(tmp);
     152                res++;
     153            }
     154            /* is format sensible? */
     155            if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
     156                asprintf(&tmp, " %s has unsupported format.", device);
     157                log_it(tmp);
     158                strcat(flaws_str, tmp);
     159                paranoid_free(tmp);
     160                res++;
     161            }
     162            amount_allocated += mountlist->el[pos].size / 1024;
     163            prev_sp_no = cur_sp_no;
     164
     165            paranoid_free(device);
     166        }
     167    }
     168
     169    npos = pos = 0;
     170    for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
     171        asprintf(&device, "%ss%d", drive, curr_part_no);
     172        pos = find_device_in_mountlist(mountlist, device);
     173        npos = 0;
     174        for (cur_sp_no = 'a'; cur_sp_no <= 'h'; cur_sp_no++) {
     175            sprintf(device, "%ss%i%c", device, curr_part_no, cur_sp_no);
     176            if (find_device_in_mountlist(mountlist, device) >= 0)
     177                npos++;
     178        }
     179        paranoid_free(device);
     180
     181        if (((pos >= 0) || npos) && foundsome) {
     182            sprintf(flaws_str + strlen(flaws_str),
     183                    " %s has both DD and PC-style partitions.", drive);
     184            return ++res;       // fatal error
     185        }
     186
     187        // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
     188        if (pos > 0 && !npos) {
     189            asprintf(&device, "%ss%d", drive, curr_part_no);
     190            /* gap in the partition list? */
     191            if (curr_part_no - prev_part_no > 1) {
     192                if (prev_part_no == 0) {
     193                    asprintf(&tmp, " Gap prior to %s.", device);
     194                    log_it(tmp);
     195                    strcat(flaws_str, tmp);
     196                    paranoid_free(tmp);
     197                    res++;
     198                } else if (curr_part_no > 5
     199                           || (curr_part_no <= 4 && prev_part_no > 0)) {
     200                    asprintf(&tmp, " Gap between %ss%d and %d.", drive,
     201                            prev_part_no, curr_part_no);
     202                    log_it(tmp);
     203                    strcat(flaws_str, tmp);
     204                    paranoid_free(tmp);
     205                    res++;
     206                }
     207            }
     208            /* GPT allows more than 4 primary partitions */
     209            part_table_fmt = which_partition_format(drive);
     210            /* no spare primary partitions to help accommodate the logical(s)? */
     211            if ((curr_part_no >= 5 && prev_part_no == 4)
     212                && (strcmp(part_table_fmt, "MBR") == 0)) {
     213                asprintf(&tmp, " Partition %ss4 is occupied.", drive);
     214                log_it(tmp);
     215                strcat(flaws_str, tmp);
     216                paranoid_free(tmp);
     217                res++;
     218            }
     219            /* does partition /dev/adXsY exist more than once in the mountlist? */
     220            for (i = 0, mountpoint_copies = 0, device_copies = 0;
     221                 i < mountlist->entries; i++) {
     222                if (!strcmp(device, mountlist->el[i].device)) {
     223                    device_copies++;
     224                }
     225            }
     226            if (device_copies > 1) {
     227                asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
     228                        device);
     229                if (!strstr(flaws_str, tmp)) {
     230                    log_it(tmp);
     231                    strcat(flaws_str, tmp);
     232                    res++;
     233                }
     234                paranoid_free(tmp);
     235            }
     236            /* silly partition size? */
     237            if (mountlist->el[pos].size < 8192
     238                && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
     239                asprintf(&tmp, " %s is tiny!", device);
     240                log_it(tmp);
     241                strcat(flaws_str, tmp);
     242                paranoid_free(tmp);
     243                res++;
     244            }
     245            /* mountpoint should begin with / unless it is swap, lvm or raid */
     246            if (strcmp(mountlist->el[pos].mountpoint, "swap")
     247                && strcmp(mountlist->el[pos].mountpoint, "lvm")
     248                && strcmp(mountlist->el[pos].mountpoint, "raid")
     249                && strcmp(mountlist->el[pos].mountpoint, "image")
     250                && strcmp(mountlist->el[pos].mountpoint, "none")
     251                && mountlist->el[pos].mountpoint[0] != '/') {
     252                asprintf(&tmp, " %s has a weird mountpoint.", device);
     253                log_it(tmp);
     254                strcat(flaws_str, tmp);
     255                paranoid_free(tmp);
     256                res++;
     257            }
     258            /* is format sensible? */
     259            if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
     260                asprintf(&tmp, " %s has unsupported format.", device);
     261                log_it(tmp);
     262                strcat(flaws_str, tmp);
     263                paranoid_free(tmp);
     264                res++;
     265            }
     266            paranoid_free(device);
     267        } else {
     268            /* Check subpartitions */
     269            for (cur_sp_no = 'a'; cur_sp_no < 'z'; ++cur_sp_no) {
     270                asprintf(&device, "%ss%d%c", drive, curr_part_no, cur_sp_no);
     271                pos = find_device_in_mountlist(mountlist, device);
     272                if (pos < 0) {
     273                    continue;
     274                }
     275                // BERLIOS : useless ? asprintf(&mountpoint, mountlist->el[pos].mountpoint);
     276                /* is it too big? */
     277                if (curr_part_no > 'h') {
     278                    asprintf(&tmp, " Can only have up to 'h' in disklabel.");
     279                    log_it(tmp);
     280                    strcat(flaws_str, tmp);
     281                    paranoid_free(tmp);
     282                    res++;
     283                }
     284                /* does partition /dev/adXsYZ exist more than once in the mountlist? */
     285                for (i = 0, mountpoint_copies = 0, device_copies = 0;
     286                     i < mountlist->entries; i++) {
     287                    if (!strcmp(device, mountlist->el[i].device)) {
     288                        device_copies++;
     289                    }
     290                }
     291                if (device_copies > 1) {
     292                    asprintf(&tmp, " %s %s's.",
     293                            number_to_text(device_copies), device);
     294                    if (!strstr(flaws_str, tmp)) {
     295                        log_it(tmp);
     296                        strcat(flaws_str, tmp);
     297                        res++;
     298                    }
     299                    paranoid_free(tmp);
     300                }
     301                /* silly partition size? */
     302                if (mountlist->el[pos].size < 8192
     303                    && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
     304                    asprintf(&tmp, " %s is tiny!", device);
     305                    log_it(tmp);
     306                    strcat(flaws_str, tmp);
     307                    paranoid_free(tmp);
     308                    res++;
     309                }
     310                /* mountpoint should begin with / unless it is swap, lvm or raid */
     311                if (strcmp(mountlist->el[pos].mountpoint, "swap")
     312                    && strcmp(mountlist->el[pos].mountpoint, "lvm")
     313                    && strcmp(mountlist->el[pos].mountpoint, "raid")
     314                    && strcmp(mountlist->el[pos].mountpoint, "image")
     315                    && strcmp(mountlist->el[pos].mountpoint, "none")
     316                    && mountlist->el[pos].mountpoint[0] != '/') {
     317                    asprintf(&tmp, " %s has a weird mountpoint.", device);
     318                    log_it(tmp);
     319                    strcat(flaws_str, tmp);
     320                    paranoid_free(tmp);
     321                    res++;
     322                }
     323                /* is format sensible? */
     324                if (!is_this_a_valid_disk_format
     325                    (mountlist->el[pos].format)) {
     326                    asprintf(&tmp, " %s has unsupported format.", device);
     327                    log_it(tmp);
     328                    strcat(flaws_str, tmp);
     329                    paranoid_free(tmp);
     330                    res++;
     331                }
     332                amount_allocated += mountlist->el[pos].size / 1024;
     333                prev_sp_no = cur_sp_no;
     334                paranoid_free(device);
     335            }
     336        }
     337
     338        /* OK, continue with main loop */
     339        amount_allocated += mountlist->el[pos].size / 1024;
     340        prev_part_no = curr_part_no;
     341    }
     342
     343    /* Over-allocated the disk? Unallocated space on disk? */
     344    if (amount_allocated > physical_drive_size) // Used to be +1, but what if you're 1 MB too high?
     345    {
     346        asprintf(&tmp, " %ld MB over-allocated on %s.",
     347                amount_allocated - physical_drive_size, drive);
     348        log_it(tmp);
     349        strcat(flaws_str, tmp);
     350        paranoid_free(tmp);
     351        res++;
     352    } else if (amount_allocated < physical_drive_size - 1) {    /* NOT AN ERROR, JUST A WARNING :-) */
     353        asprintf(&tmp, " %ld MB unallocated on %s.",
     354                physical_drive_size - amount_allocated, drive);
     355        log_it(tmp);
     356        strcat(flaws_str, tmp);
     357        paranoid_free(tmp);
     358    }
     359    if (res) {
     360        return (FALSE);
     361    } else {
     362        return (TRUE);
     363    }
    410364}
    411365
    … …  
    414368{
    415369
    416     /*@ int **************************************************************/
    417   int prev_part_no = 0;
     370    /*@ int ************************************************************* */
     371    int prev_part_no = 0;
    418372    int curr_part_no = 0;
    419373    int pos = 0;
    … …  
    423377    int i = 0;
    424378
    425     /*@ buffers *********************************************************/
    426   char *tmp;
     379    /*@ buffers ******************************************************** */
     380    char *tmp;
    427381    char *device;
    428382    char *mountpoint;
    429383
    430     /*@ long ************************************************************/
    431   long physical_drive_size = 0;
     384    /*@ long *********************************************************** */
     385    long physical_drive_size = 0;
    432386    long amount_allocated = 0;
    433387
    434     /*@ pointers ********************************************************/
     388    /*@ pointers ******************************************************* */
    435389    char *part_table_fmt;
    436390
    437     /*@ initialize ******************************************************/
    438   assert_string_is_neither_NULL_nor_zerolength(drive);
    439   assert(mountlist!=NULL);
    440   assert(flaws_str!=NULL);
    441 
    442   malloc_string(tmp);
    443   malloc_string(device);
    444   malloc_string(mountpoint);
    445   flaws_str[0] = '\0';
    446   prev_part_no = 0;
    447   tmp[0] = '\0';
    448 
    449 
    450   physical_drive_size = get_phys_size_of_drive (drive);
    451 
    452   if (physical_drive_size < 0)
    453     {
    454       sprintf (tmp, " %s does not exist.", drive);
    455       strcat (flaws_str, tmp);
    456       res++;
    457       log_msg(1, tmp);
    458       goto endoffunc;
    459     }
    460   else
    461     {
    462       sprintf (tmp, "%s is %ld MB", drive, physical_drive_size);
    463       log_it (tmp);
    464     }
    465 
    466   for (curr_part_no = 1; curr_part_no < 99; curr_part_no++)
    467     {
    468       sprintf (device, "%s%d", drive, curr_part_no);
    469       pos = find_device_in_mountlist (mountlist, device);
    470       if (pos < 0)
    471     {
    472       continue;
    473     }
    474       if (physical_drive_size < 0)
    475         {
    476           sprintf(tmp, " %s refers to non-existent hardware.", device);
    477           strcat (flaws_str, tmp);
    478           res++;
    479           continue;
    480         }
    481       strcpy (mountpoint, mountlist->el[pos].mountpoint);
    482       /* gap in the partition list? */
    483       if (curr_part_no - prev_part_no > 1)
    484     {
    485       if (prev_part_no == 0)
    486         {
    487           sprintf (tmp, " Gap prior to %s.", device);
    488           log_it (tmp);
    489           strcat (flaws_str, tmp);
    490           res++;
    491         }
    492       else if (curr_part_no > 5
    493            || (curr_part_no <= 4 && prev_part_no > 0))
    494         {
    495           sprintf (tmp, " Gap between %s%d and %d.", drive, prev_part_no,
    496                curr_part_no);
    497           log_it (tmp);
    498           strcat (flaws_str, tmp);
    499           res++;
    500         }
    501     }
    502       /* GPT allows more than 4 primary partitions */
    503       part_table_fmt = which_partition_format(drive);
    504       /* no spare primary partitions to help accommodate the logical(s)? */
    505       if ((curr_part_no >= 5 && prev_part_no == 4) && (strcmp(part_table_fmt,"MBR") == 0))
    506     {
    507       sprintf (tmp, " Partition %s4 is occupied.", drive);
    508       log_it (tmp);
    509       strcat (flaws_str, tmp);
    510       res++;
    511     }
    512       /* does partition /dev/hdNX exist more than once in the mountlist? */
    513       for (i = 0, mountpoint_copies = 0, device_copies = 0;
    514        i < mountlist->entries; i++)
    515     {
    516       if (!strcmp (device, mountlist->el[i].device))
    517         {
    518           device_copies++;
    519         }
    520     }
    521       if (device_copies > 1)
    522     {
    523       sprintf (tmp, " %s %s's.", number_to_text (device_copies), device);
    524       if (!strstr (flaws_str, tmp))
    525         {
    526           log_it (tmp);
    527           strcat (flaws_str, tmp);
    528           res++;
    529         }
    530     }
    531       /* silly partition size? */
    532       if (mountlist->el[pos].size < 8192
    533       && strcmp (mountlist->el[pos].mountpoint, "lvm"))
    534     {
    535       sprintf (tmp, " %s is tiny!", device);
    536       log_it (tmp);
    537       strcat (flaws_str, tmp);
    538       res++;
    539     }
    540       /* mountpoint should begin with / unless it is swap, lvm or raid */
    541       if (strcmp (mountlist->el[pos].mountpoint, "swap")
    542       && strcmp (mountlist->el[pos].mountpoint, "lvm")
    543       && strcmp (mountlist->el[pos].mountpoint, "raid")
    544       && strcmp (mountlist->el[pos].mountpoint, "image")
    545       && mountlist->el[pos].mountpoint[0] != '/')
    546     {
    547       sprintf (tmp, " %s has a weird mountpoint.", device);
    548       log_it (tmp);
    549       strcat (flaws_str, tmp);
    550       res++;
    551     }
    552       /* is format sensible? */
    553       if (!is_this_a_valid_disk_format (mountlist->el[pos].format))
    554     {
    555       sprintf (tmp, " %s has unsupported format.", device);
    556       log_it (tmp);
    557       strcat (flaws_str, tmp);
    558       res++;
    559     }
    560       /* OK, continue with main loop */
    561       amount_allocated += mountlist->el[pos].size / 1024;
    562       prev_part_no = curr_part_no;
    563     }
    564 
    565   /* Over-allocated the disk? Unallocated space on disk? */
    566   if (amount_allocated > physical_drive_size + 1)
    567     {
    568       sprintf (tmp, " %ld MB over-allocated on %s.",
    569            amount_allocated - physical_drive_size, drive);
    570       log_it (tmp);
    571       strcat (flaws_str, tmp);
    572       res++;
    573     }
    574   else if (amount_allocated < physical_drive_size - 1)
    575     {               /* NOT AN ERROR, JUST A WARNING :-) */
    576       sprintf (tmp, " %ld MB unallocated on %s.",
    577            physical_drive_size - amount_allocated, drive);
    578       log_it (tmp), strcat (flaws_str, tmp);
    579     }
    580 
    581 endoffunc:
    582   paranoid_free(tmp);
    583   paranoid_free(device);
    584   paranoid_free(mountpoint);
    585  
    586   if (res)
    587     {
    588       return (FALSE);
    589     }
    590   else
    591     {
    592       return (TRUE);
    593     }
     391    /*@ initialize ***************************************************** */
     392    assert_string_is_neither_NULL_nor_zerolength(drive);
     393    assert(mountlist != NULL);
     394    assert(flaws_str != NULL);
     395
     396    flaws_str[0] = '\0';
     397    prev_part_no = 0;
     398    // BERLIOS : useless ? tmp[0] = '\0';
     399
     400
     401    physical_drive_size = get_phys_size_of_drive(drive);
     402
     403    if (physical_drive_size < 0) {
     404        asprintf(&tmp, " %s does not exist.", drive);
     405        strcat(flaws_str, tmp);
     406        res++;
     407        log_msg(1, tmp);
     408        paranoid_free(tmp);
     409        return(FALSE);
     410    } else {
     411        asprintf(&tmp, "%s is %ld MB", drive, physical_drive_size);
     412        log_it(tmp);
     413        paranoid_free(tmp);
     414    }
     415
     416    for (curr_part_no = 1; curr_part_no < 99; curr_part_no++) {
     417        asprintf(&device, "%s%d", drive, curr_part_no);
     418        pos = find_device_in_mountlist(mountlist, device);
     419        if (pos < 0) {
     420            continue;
     421        }
     422        if (physical_drive_size < 0) {
     423            asprintf(&tmp, " %s refers to non-existent hardware.", device);
     424            strcat(flaws_str, tmp);
     425            res++;
     426            paranoid_free(tmp);
     427            continue;
     428        }
     429        // BERLIOS : useless ? strcpy(mountpoint, mountlist->el[pos].mountpoint);
     430        /* gap in the partition list? */
     431        if (curr_part_no - prev_part_no > 1) {
     432            if (prev_part_no == 0) {
     433                asprintf(&tmp, " Gap prior to %s.", device);
     434                log_it(tmp);
     435                strcat(flaws_str, tmp);
     436                paranoid_free(tmp);
     437                res++;
     438            } else if (curr_part_no > 5
     439                       || (curr_part_no <= 4 && prev_part_no > 0)) {
     440                asprintf(&tmp, " Gap between %s%d and %d.", drive,
     441                        prev_part_no, curr_part_no);
     442                log_it(tmp);
     443                strcat(flaws_str, tmp);
     444                paranoid_free(tmp);
     445                res++;
     446            }
     447        }
     448        /* GPT allows more than 4 primary partitions */
     449        part_table_fmt = which_partition_format(drive);
     450        /* no spare primary partitions to help accommodate the logical(s)? */
     451        if ((curr_part_no >= 5 && prev_part_no == 4)
     452            && (strcmp(part_table_fmt, "MBR") == 0)) {
     453            asprintf(&tmp, " Partition %s4 is occupied.", drive);
     454            log_it(tmp);
     455            strcat(flaws_str, tmp);
     456            paranoid_free(tmp);
     457            res++;
     458        }
     459        /* does partition /dev/hdNX exist more than once in the mountlist? */
     460        for (i = 0, mountpoint_copies = 0, device_copies = 0;
     461             i < mountlist->entries; i++) {
     462            if (!strcmp(device, mountlist->el[i].device)) {
     463                device_copies++;
     464            }
     465        }
     466        if (device_copies > 1) {
     467            asprintf(&tmp, " %s %s's.", number_to_text(device_copies),
     468                    device);
     469            if (!strstr(flaws_str, tmp)) {
     470                log_it(tmp);
     471                strcat(flaws_str, tmp);
     472                res++;
     473            }
     474            paranoid_free(tmp);
     475        }
     476        /* silly partition size? */
     477        if (mountlist->el[pos].size < 8192
     478            && strcmp(mountlist->el[pos].mountpoint, "lvm")) {
     479            asprintf(&tmp, " %s is tiny!", device);
     480            log_it(tmp);
     481            strcat(flaws_str, tmp);
     482            paranoid_free(tmp);
     483            res++;
     484        }
     485        /* mountpoint should begin with / unless it is swap, lvm or raid */
     486        if (strcmp(mountlist->el[pos].mountpoint, "swap")
     487            && strcmp(mountlist->el[pos].mountpoint, "lvm")
     488            && strcmp(mountlist->el[pos].mountpoint, "raid")
     489            && strcmp(mountlist->el[pos].mountpoint, "image")
     490            && mountlist->el[pos].mountpoint[0] != '/') {
     491            asprintf(&tmp, " %s has a weird mountpoint.", device);
     492            log_it(tmp);
     493            strcat(flaws_str, tmp);
     494            paranoid_free(tmp);
     495            res++;
     496        }
     497        /* is format sensible? */
     498        if (!is_this_a_valid_disk_format(mountlist->el[pos].format)) {
     499            asprintf(&tmp, " %s has unsupported format.", device);
     500            log_it(tmp);
     501            strcat(flaws_str, tmp);
     502            paranoid_free(tmp);
     503            res++;
     504        }
     505        /* OK, continue with main loop */
     506        amount_allocated += mountlist->el[pos].size / 1024;
     507        prev_part_no = curr_part_no;
     508        paranoid_free(device);
     509    }
     510
     511    /* Over-allocated the disk? Unallocated space on disk? */
     512    if (amount_allocated > physical_drive_size + 1) {
     513        asprintf(&tmp, " %ld MB over-allocated on %s.",
     514                amount_allocated - physical_drive_size, drive);
     515        log_it(tmp);
     516        strcat(flaws_str, tmp);
     517        paranoid_free(tmp);
     518        res++;
     519    } else if (amount_allocated < physical_drive_size - 1) {    /* NOT AN ERROR, JUST A WARNING :-) */
     520        asprintf(&tmp, " %ld MB unallocated on %s.",
     521                physical_drive_size - amount_allocated, drive);
     522        log_it(tmp);
     523        strcat(flaws_str, tmp);
     524        paranoid_free(tmp);
     525    }
     526
     527    if (res) {
     528        return (FALSE);
     529    } else {
     530        return (TRUE);
     531    }
    594532}
    595533#endif
    596 
    597534
    598535
    … …  
    608545 */
    609546int
    610 evaluate_mountlist (struct mountlist_itself *mountlist, char *flaws_str_A,
    611             char *flaws_str_B, char *flaws_str_C)
    612 {
    613 
    614     /*@ buffer ************************************************************/
    615     struct list_of_disks *drivelist;
     547evaluate_mountlist(struct mountlist_itself *mountlist, char *flaws_str_A,
     548                   char *flaws_str_B, char *flaws_str_C)
     549{
     550
     551    /*@ buffer *********************************************************** */
     552    struct list_of_disks *drivelist;
    616553    char *tmp;
     554    char *tmp1;
    617555    char *flaws_str;
    618556
    619     /*@ int ***************************************************************/
     557    /*@ int ************************************************************** */
    620558    int i = 0;
    621559    int res = 0;
    622560
    623     /*@ initialize ********************************************************/
    624 
    625   drivelist = malloc(sizeof(struct list_of_disks));
    626   malloc_string(tmp);
    627   malloc_string(flaws_str);
    628   assert(mountlist!=NULL);
    629   assert(flaws_str_A!=NULL);
    630   assert(flaws_str_B!=NULL);
    631   assert(flaws_str_C!=NULL);
    632   flaws_str[0] = '\0';
    633 
    634   make_list_of_drives_in_mountlist (mountlist, drivelist);
    635 
    636   log_it ("Evaluating mountlist...");
    637 
    638  for (i = 0; i < drivelist->entries; i++)
    639     {
    640       if (strstr (drivelist->el[i].device, DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE))
    641     {
    642       sprintf (tmp, " Not evaluating %s (I don't know how yet)",
    643            drivelist->el[i].device);
    644       log_it (tmp);
    645       tmp[0] = '\0';
    646     }
    647       else
    648     {
    649       if (!evaluate_drive_within_mountlist
    650           (mountlist, drivelist->el[i].device, tmp))
    651         {
    652           res++;
    653         }
    654     }
    655       strcat (flaws_str, tmp);
    656     }
    657   res += look_for_duplicate_mountpoints (mountlist, flaws_str);
     561    /*@ initialize ******************************************************* */
     562
     563    drivelist = malloc(sizeof(struct list_of_disks));
     564    assert(mountlist != NULL);
     565    assert(flaws_str_A != NULL);
     566    assert(flaws_str_B != NULL);
     567    assert(flaws_str_C != NULL);
     568
     569    asprintf(&flaws_str, "");
     570
     571    make_list_of_drives_in_mountlist(mountlist, drivelist);
     572
     573    log_it("Evaluating mountlist...");
     574
     575    for (i = 0; i < drivelist->entries; i++) {
     576        if (strstr
     577            (drivelist->el[i].device,
     578             DONT_KNOW_HOW_TO_EVALUATE_THIS_DEVICE_TYPE)) {
     579            asprintf(&tmp, " Not evaluating %s (I don't know how yet)",
     580                    drivelist->el[i].device);
     581            log_it(tmp);
     582        } else {
     583            asprintf(&tmp, "");
     584            // BERLIOS : tmp was NOT initialized ???
     585            if (!evaluate_drive_within_mountlist
     586                (mountlist, drivelist->el[i].device, tmp)) {
     587                res++;
     588            }
     589        }
     590        asprintf(&tmp1, "%s%s", flaws_str, tmp);
     591        paranoid_free(tmp);
     592        paranoid_free(flaws_str);
     593        flaws_str = tmp1;
     594    }
     595    res += look_for_duplicate_mountpoints(mountlist, flaws_str);
    658596/*  res+=look_for_weird_formats(mountlist,flaws_str); .. not necessary, now that we can check to see
    659597 which formarts are actually _supported_ by the kernel */
    660   /* log_it(flaws_str); */
    661   return (spread_flaws_across_three_lines
    662       (flaws_str, flaws_str_A, flaws_str_B, flaws_str_C, res));
     598    /* log_it(flaws_str); */
     599    return (spread_flaws_across_three_lines
     600            (flaws_str, flaws_str_A, flaws_str_B, flaws_str_C, res));
    663601}
    664602
    … …  
    672610 */
    673611int
    674 find_device_in_mountlist (struct mountlist_itself *mountlist, char *device)
    675 {
    676 
    677     /*@ int ***************************************************************/
    678   int i = 0;
    679   char*tmp;
    680   char*flaws_str;
    681  
    682   malloc_string(tmp);
    683   malloc_string(flaws_str);
    684  
    685   assert(mountlist!=NULL);
    686   assert_string_is_neither_NULL_nor_zerolength(device);
    687   for (i = 0;
    688        i < mountlist->entries
    689        && strcmp (mountlist->el[i].device, device) != 0; i++);
    690  
    691   paranoid_free(tmp);
    692   paranoid_free(flaws_str);
    693 
    694   if (i == mountlist->entries)
    695     {
    696       return (-1);
    697     }
    698   else
    699     {
    700       return (i);
    701     }
    702 }
    703 
    704 
    705 
     612find_device_in_mountlist(struct mountlist_itself *mountlist, char *device)
     613{
     614
     615    /*@ int ************************************************************** */
     616    int i = 0;
     617
     618    assert(mountlist != NULL);
     619    assert_string_is_neither_NULL_nor_zerolength(device);
     620    for (i = 0;
     621         i < mountlist->entries
     622         && strcmp(mountlist->el[i].device, device) != 0; i++);
     623
     624    if (i == mountlist->entries) {
     625        return (-1);
     626    } else {
     627        return (i);
     628    }
     629}
    706630
    707631
    … …  
    713637 */
    714638int
    715 look_for_duplicate_mountpoints (struct mountlist_itself *mountlist,
    716                 char *flaws_str)
    717 {
    718 
    719     /*@ int **************************************************************/
    720   int res = 0;
     639look_for_duplicate_mountpoints(struct mountlist_itself *mountlist,
     640                               char *flaws_str)
     641{
     642
     643    /*@ int ************************************************************* */
     644    int res = 0;
    721645    int currline = 0;
    722646    int i = 0;
    … …  
    724648    int last_copy = 0;
    725649
    726     /*@ buffetr **********************************************************/
    727   char *curr_mountpoint;
     650    /*@ buffetr ********************************************************* */
     651    char *curr_mountpoint;
    728652    char *tmp;
    729653
    730   malloc_string(curr_mountpoint);
    731   malloc_string(tmp);
    732   assert(mountlist!=NULL);
    733   assert(flaws_str!=NULL);
    734   for (currline = 0; currline < mountlist->entries; currline++)
    735     {
    736       strcpy (curr_mountpoint, mountlist->el[currline].mountpoint);
    737       for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries; i++)
    738     {
    739       if (!strcmp (mountlist->el[i].mountpoint, curr_mountpoint)
    740           && strcmp (mountlist->el[i].mountpoint, "lvm")
    741           && strcmp (mountlist->el[i].mountpoint, "swap"))
    742         {
    743           last_copy = i;
    744           copies++;
    745         }
    746     }
    747       if (copies > 1 && last_copy == currline
    748       && strcmp (curr_mountpoint, "raid"))
    749     {
    750       sprintf (tmp, " %s %s's.", number_to_text (copies),
    751            curr_mountpoint);
    752       strcat (flaws_str, tmp);
    753       log_it (tmp);
    754       res++;
    755     }
    756     }
    757   paranoid_free(curr_mountpoint);
    758   paranoid_free(tmp);
    759   return (res);
    760 }
     654    assert(mountlist != NULL);
     655    assert(flaws_str != NULL);
     656    for (currline = 0; currline < mountlist->entries; currline++) {
     657        asprintf(&curr_mountpoint, mountlist->el[currline].mountpoint);
     658        for (i = 0, copies = 0, last_copy = -1; i < mountlist->entries;
     659             i++) {
     660            if (!strcmp(mountlist->el[i].mountpoint, curr_mountpoint)
     661                && strcmp(mountlist->el[i].mountpoint, "lvm")
     662                && strcmp(mountlist->el[i].mountpoint, "swap")) {
     663                last_copy = i;
     664                copies++;
     665            }
     666        }
     667        if (copies > 1 && last_copy == currline
     668            && strcmp(curr_mountpoint, "raid")) {
     669            asprintf(&tmp, " %s %s's.", number_to_text(copies),
     670                    curr_mountpoint);
     671            strcat(flaws_str, tmp);
     672            log_it(tmp);
     673            paranoid_free(tmp);
     674            res++;
     675        }
     676        paranoid_free(curr_mountpoint);
     677    }
     678    return (res);
     679}
     680
    761681
    762682/**
    … …  
    768688 */
    769689int
    770 look_for_weird_formats (struct mountlist_itself *mountlist, char *flaws_str)
    771 {
    772 
    773     /*@ int **************************************************************/
    774   int i = 0;
     690look_for_weird_formats(struct mountlist_itself *mountlist, char *flaws_str)
     691{
     692
     693    /*@ int ************************************************************* */
     694    int i = 0;
    775695    int res = 0;
    776696
    777     /*@ buffers **********************************************************/
    778   char *tmp;
     697    /*@ buffers ********************************************************* */
     698    char *tmp;
    779699    char *format_sz;
    780700
    781   malloc_string(tmp);
    782   malloc_string(format_sz);
    783  
    784   assert(mountlist!=NULL);
    785   assert(flaws_str!=NULL);
    786 
    787   for (i = 0; i < mountlist->entries; i++)
    788     {
    789       sprintf (format_sz, " %s ", mountlist->el[i].format);
    790       if (!strstr
    791       (SANE_FORMATS, format_sz)
    792         && strcmp (mountlist->el[i].mountpoint, "image") != 0)
    793     {
    794       sprintf (tmp, " %s has unknown format.", mountlist->el[i].device);
    795       log_it (tmp);
    796       strcat (flaws_str, tmp);
    797       res++;
    798     }
    799       else
    800     if ((!strcmp (mountlist->el[i].format, "swap")
    801          && strcmp (mountlist->el[i].mountpoint, "swap") && strcmp (mountlist->el[i].mountpoint, "none"))
    802         || (strcmp (mountlist->el[i].format, "swap")
    803         && !strcmp (mountlist->el[i].mountpoint, "swap") && !strcmp (mountlist->el[i].mountpoint, "none")))
    804     {
    805       sprintf (tmp, " %s is half-swap.", mountlist->el[i].device);
    806       log_it (tmp);
    807       strcat (flaws_str, tmp);
    808       res++;
    809     }
    810     }
    811   paranoid_free(tmp);
    812   paranoid_free(format_sz);
    813   return (res);
    814 }
    815 
     701    assert(mountlist != NULL);
     702    assert(flaws_str != NULL);
     703
     704    for (i = 0; i < mountlist->entries; i++) {
     705        asprintf(&format_sz, " %s ", mountlist->el[i].format);
     706        if (!strstr(SANE_FORMATS, format_sz)
     707            && strcmp(mountlist->el[i].mountpoint, "image") != 0) {
     708            asprintf(&tmp, " %s has unknown format.",
     709                    mountlist->el[i].device);
     710            log_it(tmp);
     711            strcat(flaws_str, tmp);
     712            paranoid_free(tmp);
     713            res++;
     714        } else if ((!strcmp(mountlist->el[i].format, "swap")
     715                    && strcmp(mountlist->el[i].mountpoint, "swap")
     716                    && strcmp(mountlist->el[i].mountpoint, "none"))
     717                   || (strcmp(mountlist->el[i].format, "swap")
     718                       && !strcmp(mountlist->el[i].mountpoint, "swap")
     719                       && !strcmp(mountlist->el[i].mountpoint, "none"))) {
     720            asprintf(&tmp, " %s is half-swap.", mountlist->el[i].device);
     721            log_it(tmp);
     722            strcat(flaws_str, tmp);
     723            paranoid_free(tmp);
     724            res++;
     725        }
     726        paranoid_free(format_sz);
     727    }
     728    return (res);
     729}
    816730
    817731
    … …  
    823737 */
    824738int
    825 make_list_of_drives_in_mountlist (struct mountlist_itself *mountlist,
    826              struct list_of_disks *drivelist)
    827 {
    828 
    829         /*@ int **************************************************************/
    830   int lino;
    831   int noof_drives;
    832   int j;
    833 
    834         /*@ buffers **********************************************************/
    835   char *drive;
    836   char *tmp;
    837 
    838   long long size;
    839 
    840   malloc_string(drive);
    841   malloc_string(tmp);
    842   assert(mountlist!=NULL);
    843   assert(drivelist!=NULL);
    844   log_it ("Making list of drives");
    845   for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++)
    846     {
    847      
    848       strcpy (drive, mountlist->el[lino].device);
    849       if (!strncmp (drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB)))
    850     {
    851       sprintf (tmp,
    852            "Not putting %s in list of drives: it's a virtual drive",
    853            drive);
    854       log_msg (8, tmp);
    855       continue;
    856     }
    857 
    858       size=mountlist->el[lino].size;
    859       if ( size == 0 )
    860         {
    861           sprintf (tmp,
    862                    "Not putting %s in list of drives: it has zero size (maybe an LVM volume)",
    863                    drive);
    864           log_msg (8, tmp);
    865           continue;
    866         }
     739make_list_of_drives_in_mountlist(struct mountlist_itself *mountlist,
     740                                 struct list_of_disks *drivelist)
     741{
     742
     743    /*@ int ************************************************************* */
     744    int lino;
     745    int noof_drives;
     746    int j;
     747
     748    /*@ buffers ********************************************************* */
     749    char *drive;
     750    char *tmp;
     751
     752    long long size;
     753
     754    assert(mountlist != NULL);
     755    assert(drivelist != NULL);
     756    log_it("Making list of drives");
     757    for (lino = 0, noof_drives = 0; lino < mountlist->entries; lino++) {
     758
     759        asprintf(&drive, mountlist->el[lino].device);
     760        if (!strncmp(drive, RAID_DEVICE_STUB, strlen(RAID_DEVICE_STUB))) {
     761            asprintf(&tmp,
     762                    "Not putting %s in list of drives: it's a virtual drive",
     763                    drive);
     764            log_msg(8, tmp);
     765            paranoid_free(tmp);
     766            continue;
     767        }
     768
     769        size = mountlist->el[lino].size;
     770        if (size == 0) {
     771            asprintf(&tmp,
     772                    "Not putting %s in list of drives: it has zero size (maybe an LVM volume)",
     773                    drive);
     774            log_msg(8, tmp);
     775            paranoid_free(tmp);
     776            continue;
     777        }
    867778
    868779/*
    … …  
    877788*/
    878789
    879       sprintf (tmp,
    880            "Putting %s with size %lli in list of drives",
    881            drive, size);
    882       log_msg (8, tmp);
    883 
    884       (void) truncate_to_drive_name (drive);
    885       for (j = 0; j < noof_drives && strcmp (drivelist->el[j].device, drive) != 0; j++)
    886     continue;
    887       if (j == noof_drives)
    888     {
    889       strcpy (drivelist->el[noof_drives++].device, drive);
    890     }
    891     }
    892   drivelist->entries = noof_drives;
    893   log_msg (8, "Made list of drives");
    894   paranoid_free(drive);
    895   paranoid_free(tmp);
    896 
    897   return (noof_drives);
    898 }
    899 
    900 
    901 
    902 
     790        asprintf(&tmp,
     791                "Putting %s with size %lli in list of drives",
     792                drive, size);
     793        log_msg(8, tmp);
     794        paranoid_free(tmp);
     795
     796        (void) truncate_to_drive_name(drive);
     797        for (j = 0;
     798             j < noof_drives
     799             && strcmp(drivelist->el[j].device, drive) != 0; j++)
     800            continue;
     801        if (j == noof_drives) {
     802            strcpy(drivelist->el[noof_drives++].device, drive);
     803        }
     804        paranoid_free(drive);
     805
     806    }
     807    drivelist->entries = noof_drives;
     808    log_msg(8, "Made list of drives");
     809
     810    return (noof_drives);
     811}
    903812
    904813
    … …  
    910819 * @param raidlist The raidlist to examine.
    911820 */
    912 void
    913 make_list_of_unallocated_raid_partitions (struct mountlist_itself
    914                       *output_list,
    915                       struct mountlist_itself *mountlist,
    916                       struct raidlist_itself *raidlist)
    917 {
    918 
    919     /*@ int **************************************************************/
    920   int items = 0;
     821void make_list_of_unallocated_raid_partitions(struct mountlist_itself
     822                                              *output_list,
     823                                              struct mountlist_itself
     824                                              *mountlist,
     825                                              struct raidlist_itself
     826                                              *raidlist)
     827{
     828
     829    /*@ int ************************************************************* */
     830    int items = 0;
    921831    int i = 0;
    922832    int used_by = 0;
    923833
    924     /*@ buffers **********************************************************/
    925   char *tmp;
    926 
    927   malloc_string(tmp);
    928   assert(output_list!=NULL);
    929   assert(mountlist!=NULL);
    930   assert(raidlist!=NULL);
    931   log_it ("MLOURP -- starting");
    932   items = 0;
    933 
    934 
    935   for (i = 0; i < mountlist->entries; i++)
    936     {
    937       if (strstr (mountlist->el[i].mountpoint, "raid"))
    938     {
    939       used_by =
    940         which_raid_device_is_using_this_partition (raidlist,
    941                                mountlist->el[i].
    942                                device);
    943       if (used_by < 0)
    944         {
    945           memcpy ((void *) &output_list->el[items++],
    946               (void *) &mountlist->el[i],
    947               sizeof (struct mountlist_line));
    948           sprintf (tmp,
    949                "%s is available; user may choose to add it to raid device",
    950                output_list->el[items - 1].device);
    951           log_it (tmp);
    952         }
    953     }
    954     }
    955   output_list->entries = items;
    956   log_it ("MLUORP -- ending");
    957   paranoid_free(tmp);
    958 }
    959 
    960 
    961 
     834    /*@ buffers ********************************************************* */
     835    char *tmp;
     836
     837    assert(output_list != NULL);
     838    assert(mountlist != NULL);
     839    assert(raidlist != NULL);
     840    log_it("MLOURP -- starting");
     841    items = 0;
     842
     843
     844    for (i = 0; i < mountlist->entries; i++) {
     845        if (strstr(mountlist->el[i].mountpoint, "raid")) {
     846            used_by =
     847                which_raid_device_is_using_this_partition(raidlist,
     848                                                          mountlist->el[i].
     849                                                          device);
     850            if (used_by < 0) {
     851                memcpy((void *) &output_list->el[items++],
     852                       (void *) &mountlist->el[i],
     853                       sizeof(struct mountlist_line));
     854                asprintf(&tmp,
     855                        "%s is available; user may choose to add it to raid device",
     856                        output_list->el[items - 1].device);
     857                log_it(tmp);
     858                paranoid_free(tmp);
     859            }
     860        }
     861    }
     862    output_list->entries = items;
     863    log_it("MLUORP -- ending");
     864}
    962865
    963866
    … …  
    969872 */
    970873long long
    971 size_of_specific_device_in_mountlist (struct mountlist_itself *mountlist, char *device)
    972 {
    973     /*@ int ***************************************************************/
    974   int i = 0;
    975 
    976 
    977   assert(mountlist!=NULL);
    978   assert_string_is_neither_NULL_nor_zerolength(device);
    979 
    980   for (i = 0;
    981        i < mountlist->entries && strcmp (mountlist->el[i].device, device);
    982        i++);
    983   if (i == mountlist->entries)
    984     {
    985       return (-1);
    986     }
    987   else
    988     {
    989       return (mountlist->el[i].size);
    990     }
    991 }
    992 
    993 
     874size_of_specific_device_in_mountlist(struct mountlist_itself *mountlist,
     875                                     char *device)
     876{
     877    /*@ int ************************************************************** */
     878    int i = 0;
     879
     880
     881    assert(mountlist != NULL);
     882    assert_string_is_neither_NULL_nor_zerolength(device);
     883
     884    for (i = 0;
     885         i < mountlist->entries && strcmp(mountlist->el[i].device, device);
     886         i++);
     887    if (i == mountlist->entries) {
     888        return (-1);
     889    } else {
     890        return (mountlist->el[i].size);
     891    }
     892}
    994893
    995894
    … …  
    1004903 * @return 0 for success, 1 for failure.
    1005904 */
    1006 int
    1007 load_mountlist( struct mountlist_itself *mountlist, char *fname)
    1008 {
    1009   FILE *fin;
    1010   /* malloc ***/
    1011   char *incoming;
    1012   char *siz;
    1013   char *tmp;
    1014   char*p;
    1015 
    1016   int items;
    1017   int j;
    1018 
    1019   assert(mountlist!=NULL);
    1020   assert_string_is_neither_NULL_nor_zerolength(fname);
    1021   malloc_string(incoming);
    1022   malloc_string(siz);
    1023   malloc_string(tmp);
    1024   if ( !( fin = fopen( fname, "r" ) ) )
    1025     {
    1026       log_it( "Unable to open mountlist - '%s'", fname );
    1027       log_to_screen( "Cannot open mountlist" );
    1028       paranoid_free(incoming);
    1029       paranoid_free(siz);
    1030       paranoid_free(tmp);
    1031       return( 1 );
    1032     }
    1033   items = 0;
    1034   (void) fgets( incoming, MAX_STR_LEN - 1, fin );
    1035   log_it( "Loading mountlist..." );
    1036   while( !feof( fin ) )
    1037     {
     905int load_mountlist(struct mountlist_itself *mountlist, char *fname)
     906{
     907    FILE *fin;
     908    /* malloc ** */
     909    char *incoming = NULL;
     910    char *siz;
     911    char *tmp;
     912    char *p;
     913
     914    int items;
     915    int j;
     916    int n = 0;
     917
     918    assert(mountlist != NULL);
     919    assert_string_is_neither_NULL_nor_zerolength(fname);
     920    malloc_string(siz);
     921    if (!(fin = fopen(fname, "r"))) {
     922        log_it("Unable to open mountlist - '%s'", fname);
     923        log_to_screen("Cannot open mountlist");
     924        paranoid_free(siz);
     925        return (1);
     926    }
     927    items = 0;
     928    (void) getline(&incoming, &n, fin);
     929    log_it("Loading mountlist...");
     930    while (!feof(fin)) {
    1038931#if linux
    1039       sscanf( incoming,
    1040           "%s %s %s %s %s",
    1041           mountlist->el[items].device,
    1042           mountlist->el[items].mountpoint,
    1043           mountlist->el[items].format,
    1044           siz,
    1045           mountlist->el[items].label);
     932        sscanf(incoming,
     933               "%s %s %s %s %s",
     934               mountlist->el[items].device,
     935               mountlist->el[items].mountpoint,
     936               mountlist->el[items].format,
     937               siz, mountlist->el[items].label);
    1046938#elif __FreeBSD__
    1047       sscanf (incoming,
    1048           "%s %s %s %s",
    1049           mountlist->el[items].device,
    1050           mountlist->el[items].mountpoint,
    1051           mountlist->el[items].format,
    1052           siz);
    1053       strcpy (mountlist->el[items].label, "");
     939        sscanf(incoming,
     940               "%s %s %s %s",
     941               mountlist->el[items].device,
     942               mountlist->el[items].mountpoint,
     943               mountlist->el[items].format, siz);
     944        strcpy(mountlist->el[items].label, "");
    1054945#endif
    1055946
    1056       if (
    1057         !strcmp(mountlist->el[items].device,"/proc") ||
    1058         !strcmp(mountlist->el[items].device, "proc") ||
    1059         !strcmp(mountlist->el[items].device,"/sys") ||
    1060         !strcmp(mountlist->el[items].device, "sys") ||
    1061         !strcmp(mountlist->el[items].device,"/devpts") ||
    1062     !strcmp(mountlist->el[items].device, "devpts")
    1063       )
    1064         {
    1065       log_msg(1, "Ignoring %s in mountlist - not loading that line :) ", mountlist->el[items].device);
    1066           (void) fgets( incoming, MAX_STR_LEN - 1,fin );
    1067       continue;
    1068     }
    1069       mountlist->el[items].size = atoll( siz );
    1070       if ( mountlist->el[items].device[0] != '\0' && mountlist->el[items].device[0] != '#' )
    1071     {
    1072       if ( items >= ARBITRARY_MAXIMUM )
    1073         {
    1074           log_to_screen( "Too many lines in mountlist.. ABORTING" );
    1075           finish( 1 );
    1076         }
    1077       for( j=0; j < items && strcmp( mountlist->el[j].device, mountlist->el[items].device ); j++);
    1078       if (j < items)
    1079         {
    1080           strcat( mountlist->el[items].device, "_dup" );
    1081           sprintf( tmp, "Duplicate entry in mountlist - renaming to %s",mountlist->el[items].device );
    1082           log_it( tmp );
    1083         }
    1084     strcpy(tmp, mountlist->el[items].device);
    1085     if (strstr(tmp, "/dev/md/"))
    1086       {
    1087         log_it("format_device() --- Contracting %s", tmp);
    1088         p = strrchr(tmp, '/');
    1089         if (p) { *p = *(p+1); *(p+1) = *(p+2); *(p+2) = *(p+3); }
    1090         log_it("It was %s; it is now %s", mountlist->el[items].device, tmp);
    1091         strcpy(mountlist->el[items].device, tmp);
    1092       }
    1093 
    1094       sprintf( tmp,
    1095            "%s %s %s %lld %s",
    1096            mountlist->el[items].device,
    1097            mountlist->el[items].mountpoint,
    1098            mountlist->el[items].format,
    1099            mountlist->el[items].size,
    1100            mountlist->el[items].label);
    1101 
    1102       log_it( tmp );
    1103       items++;
    1104     }
    1105       (void) fgets( incoming, MAX_STR_LEN - 1,fin );
    1106     }
    1107   paranoid_fclose( fin );
    1108   mountlist->entries = items;
    1109 
    1110   log_it( "Mountlist loaded successfully." );
    1111   sprintf( tmp, "%d entries in mountlist", items );
    1112   log_it( tmp );
    1113   paranoid_free(incoming);
    1114   paranoid_free(siz);
    1115   paranoid_free(tmp);
    1116   return( 0 );
     947        if (!strcmp(mountlist->el[items].device, "/proc") ||
     948            !strcmp(mountlist->el[items].device, "proc") ||
     949            !strcmp(mountlist->el[items].device, "/sys") ||
     950            !strcmp(mountlist->el[items].device, "sys") ||
     951            !strcmp(mountlist->el[items].device, "/devpts") ||
     952            !strcmp(mountlist->el[items].device, "devpts")
     953            ) {
     954            log_msg(1,
     955                    "Ignoring %s in mountlist - not loading that line :) ",
     956                    mountlist->el[items].device);
     957            (void) getline(&incoming, &n, fin);
     958            continue;
     959        }
     960        mountlist->el[items].size = atoll(siz);
     961        if (mountlist->el[items].device[0] != '\0'
     962            && mountlist->el[items].device[0] != '#') {
     963            if (items >= ARBITRARY_MAXIMUM) {
     964                log_to_screen("Too many lines in mountlist.. ABORTING");
     965                finish(1);
     966            }
     967            for (j = 0;
     968                 j < items
     969                 && strcmp(mountlist->el[j].device,
     970                           mountlist->el[items].device); j++);
     971            if (j < items) {
     972                strcat(mountlist->el[items].device, "_dup");
     973                asprintf(&tmp,
     974                        "Duplicate entry in mountlist - renaming to %s",
     975                        mountlist->el[items].device);
     976                log_it(tmp);
     977                paranoid_free(tmp);
     978            }
     979            asprintf(&tmp, mountlist->el[items].device);
     980            if (strstr(tmp, "/dev/md/")) {
     981                log_it("format_device() --- Contracting %s", tmp);
     982                p = strrchr(tmp, '/');
     983                if (p) {
     984                    *p = *(p + 1);
     985                    *(p + 1) = *(p + 2);
     986                    *(p + 2) = *(p + 3);
     987                }
     988                log_it("It was %s; it is now %s",
     989                       mountlist->el[items].device, tmp);
     990                strcpy(mountlist->el[items].device, tmp);
     991            }
     992            paranoid_free(tmp);
     993
     994            asprintf(&tmp,
     995                    "%s %s %s %lld %s",
     996                    mountlist->el[items].device,
     997                    mountlist->el[items].mountpoint,
     998                    mountlist->el[items].format,
     999                    mountlist->el[items].size, mountlist->el[items].label);
     1000
     1001            log_it(tmp);
     1002            paranoid_free(tmp);
     1003            items++;
     1004        }
     1005        (void) getline(&incoming, &n, fin);
     1006    }
     1007    paranoid_fclose(fin);
     1008    paranoid_free(incoming);
     1009    mountlist->entries = items;
     1010
     1011    log_it("Mountlist loaded successfully.");
     1012    asprintf(&tmp, "%d entries in mountlist", items);
     1013    log_it(tmp);
     1014    paranoid_free(tmp);
     1015
     1016    paranoid_free(siz);
     1017    return (0);
    11171018}
    11181019
    … …  
    11261027 * @see load_mountlist
    11271028 */
    1128 int
    1129 save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname)
    1130 {
    1131   FILE *fout;
    1132   int i;
    1133 
    1134   assert(mountlist!=NULL);
    1135   assert_string_is_neither_NULL_nor_zerolength(fname);
    1136 
    1137   log_it("save_mountlist_to_disk() --- saving to %s", fname);
    1138   if (!(fout=fopen(fname,"w")))
    1139     {
    1140       log_OS_error("WMTD - Cannot openout mountlist");
    1141       return(1);
    1142     }
    1143   for( i = 0; i < mountlist->entries; i++)
    1144     {
    1145       fprintf(fout,
    1146           "%-15s %-15s %-15s %-15lld %-15s\n",mountlist->el[i].device,
    1147           mountlist->el[i].mountpoint,
    1148           mountlist->el[i].format,
    1149           mountlist->el[i].size,
    1150           mountlist->el[i].label);
    1151     }
    1152   paranoid_fclose(fout);
    1153   return(0);
    1154 }
    1155 
     1029int save_mountlist_to_disk(struct mountlist_itself *mountlist, char *fname)
     1030{
     1031    FILE *fout;
     1032    int i;
     1033
     1034    assert(mountlist != NULL);
     1035    assert_string_is_neither_NULL_nor_zerolength(fname);
     1036
     1037    log_it("save_mountlist_to_disk() --- saving to %s", fname);
     1038    if (!(fout = fopen(fname, "w"))) {
     1039        log_OS_error("WMTD - Cannot openout mountlist");
     1040        return (1);
     1041    }
     1042    for (i = 0; i < mountlist->entries; i++) {
     1043        fprintf(fout,
     1044                "%-15s %-15s %-15s %-15lld %-15s\n",
     1045                mountlist->el[i].device, mountlist->el[i].mountpoint,
     1046                mountlist->el[i].format, mountlist->el[i].size,
     1047                mountlist->el[i].label);
     1048    }
     1049    paranoid_fclose(fout);
     1050    return (0);
     1051}
    11561052
    11571053
    … …  
    11611057 * @param mountlist The mountlist to sort.
    11621058 */
    1163 void
    1164 sort_mountlist_by_device( struct mountlist_itself *mountlist)
    1165 {
    1166   int diff;
    1167   int lino = -999;
    1168 
    1169   assert(mountlist!=NULL);
    1170 
    1171   while (lino < mountlist->entries)
    1172     {
    1173       for(lino = 1; lino < mountlist->entries; lino++)
    1174     {
    1175       diff = strcmp_inc_numbers(mountlist->el[lino-1].device,mountlist->el[lino].device);
    1176       if (diff > 0)
    1177         {
    1178           swap_mountlist_entries( mountlist, lino - 1, lino);
    1179           break;
    1180         }
    1181     }
    1182     }
    1183 }
     1059void sort_mountlist_by_device(struct mountlist_itself *mountlist)
     1060{
     1061    int diff;
     1062    int lino = -999;
     1063
     1064    assert(mountlist != NULL);
     1065
     1066    while (lino < mountlist->entries) {
     1067        for (lino = 1; lino < mountlist->entries; lino++) {
     1068            diff =
     1069                strcmp_inc_numbers(mountlist->el[lino - 1].device,
     1070                                   mountlist->el[lino].device);
     1071            if (diff > 0) {
     1072                swap_mountlist_entries(mountlist, lino - 1, lino);
     1073                break;
     1074            }
     1075        }
     1076    }
     1077}
     1078
    11841079
    11851080/**
    … …  
    11891084 * @param reverse If TRUE, then do a reverse sort.
    11901085 */
    1191 void 
    1192 sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist, bool reverse)
    1193 {
    1194   int diff;
    1195   int lino = -999;
    1196 
    1197   assert(mountlist!=NULL);
    1198 
    1199   while(lino < mountlist->entries)
    1200     {
    1201       for(lino = 1; lino < mountlist->entries; lino++)
    1202     {
    1203       diff = strcmp( mountlist->el[lino-1].mountpoint,mountlist->el[lino].mountpoint);
    1204       if ((diff >0 && !reverse) || ((diff <0 && reverse)))
    1205         {
    1206           swap_mountlist_entries(mountlist, lino - 1, lino);
    1207           break;
    1208         }
    1209     }
    1210     }
     1086void
     1087sort_mountlist_by_mountpoint(struct mountlist_itself *mountlist,
     1088                             bool reverse)
     1089{
     1090    int diff;
     1091    int lino = -999;
     1092
     1093    assert(mountlist != NULL);
     1094
     1095    while (lino < mountlist->entries) {
     1096        for (lino = 1; lino < mountlist->entries; lino++) {
     1097            diff =
     1098                strcmp(mountlist->el[lino - 1].mountpoint,
     1099                       mountlist->el[lino].mountpoint);
     1100            if ((diff > 0 && !reverse) || ((diff < 0 && reverse))) {
     1101                swap_mountlist_entries(mountlist, lino - 1, lino);
     1102                break;
     1103            }
     1104        }
     1105    }
    12111106}
    12121107
    … …  
    12181113 * @param b The index number of the second entry.
    12191114 */
    1220 void 
     1115void
    12211116swap_mountlist_entries(struct mountlist_itself *mountlist, int a, int b)
    12221117{
    1223   /*@ mallocs ****/
    1224   char device[64];
    1225   char mountpoint[256];
    1226   char format[64];
    1227 
    1228   long long size;
    1229 
    1230   assert(mountlist!=NULL);
    1231   assert(a>=0);
    1232   assert(b>=0);
    1233 
    1234   strcpy(device,                    mountlist->el[a].device);
    1235   strcpy(mountpoint,                mountlist->el[a].mountpoint);
    1236   strcpy(format,                    mountlist->el[a].format);
    1237 
    1238   size=                              mountlist->el[a].size;
    1239 
    1240   strcpy(mountlist->el[a].device,    mountlist->el[b].device);
    1241   strcpy(mountlist->el[a].mountpoint,mountlist->el[b].mountpoint);
    1242   strcpy(mountlist->el[a].format,    mountlist->el[b].format);
    1243 
    1244   mountlist->el[a].size=            mountlist->el[b].size;
    1245 
    1246   strcpy(mountlist->el[b].device,    device);
    1247   strcpy(mountlist->el[b].mountpoint,mountpoint);
    1248   strcpy(mountlist->el[b].format,    format);
    1249 
    1250   mountlist->el[b].size=            size;
     1118    /*@ mallocs *** */
     1119    char *device;
     1120    char *mountpoint;
     1121    char *format;
     1122
     1123    long long size;
     1124
     1125    assert(mountlist != NULL);
     1126    assert(a >= 0);
     1127    assert(b >= 0);
     1128
     1129    asprintf(&device, mountlist->el[a].device);
     1130    asprintf(&mountpoint, mountlist->el[a].mountpoint);
     1131    asprintf(&format, mountlist->el[a].format);
     1132
     1133    size = mountlist->el[a].size;
     1134
     1135    strcpy(mountlist->el[a].device, mountlist->el[b].device);
     1136    strcpy(mountlist->el[a].mountpoint, mountlist->el[b].mountpoint);
     1137    strcpy(mountlist->el[a].format, mountlist->el[b].format);
     1138
     1139    mountlist->el[a].size = mountlist->el[b].size;
     1140
     1141    strcpy(mountlist->el[b].device, device);
     1142    strcpy(mountlist->el[b].mountpoint, mountpoint);
     1143    strcpy(mountlist->el[b].format, format);
     1144
     1145    mountlist->el[b].size = size;
    12511146}
    12521147
Note: See TracChangeset for help on using the changeset viewer.